Add gossip for payload attestation

beacon-chain/blockchain/BUILD.bazel

@@ -27,6 +27,7 @@ go_library(
         "receive_blob.go",
         "receive_block.go",
         "receive_data_column.go",
+        "receive_payload_attestation_message.go",
         "service.go",
         "setup_forkchoice.go",
         "tracked_proposer.go",

beacon-chain/blockchain/receive_payload_attestation_message.go

@@ -0,0 +1,19 @@
+package blockchain
+
+import (
+	"context"
+
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+)
+
+// PayloadAttestationReceiver interface defines the methods of chain service for receiving
+// validated payload attestation messages.
+type PayloadAttestationReceiver interface {
+	ReceivePayloadAttestationMessage(context.Context, *ethpb.PayloadAttestationMessage) error
+}
+
+// ReceivePayloadAttestationMessage accepts a payload attestation message.
+// TODO: implement actual processing; for now this is a stub for sync integration.
+func (s *Service) ReceivePayloadAttestationMessage(ctx context.Context, a *ethpb.PayloadAttestationMessage) error {
+	return nil
+}

beacon-chain/blockchain/testing/mock.go

@@ -757,6 +757,11 @@ func (c *ChainService) ReceiveDataColumns(dcs []blocks.VerifiedRODataColumn) err
 	return nil
 }
 
+// ReceivePayloadAttestationMessage implements the same method in the chain service.
+func (c *ChainService) ReceivePayloadAttestationMessage(_ context.Context, _ *ethpb.PayloadAttestationMessage) error {
+	return nil
+}
+
 // DependentRootForEpoch mocks the same method in the chain service
 func (c *ChainService) DependentRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
 	return c.TargetRoot, nil

beacon-chain/cache/BUILD.bazel

@@ -17,6 +17,7 @@ go_library(
         "error.go",
         "interfaces.go",
         "log.go",
+        "payload_attestation.go",
         "payload_id.go",
         "proposer_indices.go",
         "proposer_indices_disabled.go",  # keep

beacon-chain/cache/payload_attestation.go

@@ -0,0 +1,62 @@
+package cache
+
+import (
+	"errors"
+	"sync"
+
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+)
+
+var errNilPayloadAttestationMessage = errors.New("nil Payload Attestation Message")
+
+// PayloadAttestationCache tracks seen payload attestation messages for a single block root.
+type PayloadAttestationCache struct {
+	root [32]byte
+	seen map[uint64]struct{}
+	sync.Mutex
+}
+
+// Seen returns true if a vote for the given beacon block root has already been
+// processed for this validator index.
+func (p *PayloadAttestationCache) Seen(root [32]byte, idx uint64) bool {
+	p.Lock()
+	defer p.Unlock()
+	if p.root != root {
+		return false
+	}
+	if p.seen == nil {
+		return false
+	}
+	_, ok := p.seen[idx]
+	return ok
+}
+
+// Add marks the given payload attestation message as seen for this validator index.
+// This function assumes that the message has already been validated.
+func (p *PayloadAttestationCache) Add(att *eth.PayloadAttestationMessage, idx uint64) error {
+	if att == nil || att.Data == nil || len(att.Data.BeaconBlockRoot) == 0 {
+		return errNilPayloadAttestationMessage
+	}
+	root := bytesutil.ToBytes32(att.Data.BeaconBlockRoot)
+
+	p.Lock()
+	defer p.Unlock()
+	if p.root != root {
+		p.root = root
+		p.seen = make(map[uint64]struct{})
+	}
+	if p.seen == nil {
+		p.seen = make(map[uint64]struct{})
+	}
+	p.seen[idx] = struct{}{}
+	return nil
+}
+
+// Clear clears the internal cache.
+func (p *PayloadAttestationCache) Clear() {
+	p.Lock()
+	defer p.Unlock()
+	p.root = [32]byte{}
+	p.seen = nil
+}

beacon-chain/core/altair/BUILD.bazel

@@ -20,7 +20,6 @@ go_library(
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
-        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",

beacon-chain/core/altair/attestation.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
@@ -76,11 +75,7 @@ func ProcessAttestationNoVerifySignature(
 		return nil, err
 	}
 
-	if err := beaconState.UpdatePendingPaymentWeight(att, indices, participatedFlags); err != nil {
-		return nil, errors.Wrap(err, "failed to update pending payment weight")
-	}
-
-	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance, att)
+	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance)
 }
 
 // SetParticipationAndRewardProposer retrieves and sets the epoch participation bits in state. Based on the epoch participation, it rewards
@@ -110,9 +105,7 @@ func SetParticipationAndRewardProposer(
 	beaconState state.BeaconState,
 	targetEpoch primitives.Epoch,
 	indices []uint64,
-	participatedFlags map[uint8]bool,
-	totalBalance uint64,
-	att ethpb.Att) (state.BeaconState, error) {
+	participatedFlags map[uint8]bool, totalBalance uint64) (state.BeaconState, error) {
 	var proposerRewardNumerator uint64
 	currentEpoch := time.CurrentEpoch(beaconState)
 	var stateErr error
@@ -306,19 +299,6 @@ func AttestationParticipationFlagIndices(beaconState state.ReadOnlyBeaconState,
 		participatedFlags[targetFlagIndex] = true
 	}
 	matchedSrcTgtHead := matchedHead && matchedSrcTgt
-
-	var beaconBlockRoot [32]byte
-	copy(beaconBlockRoot[:], data.BeaconBlockRoot)
-	matchingPayload, err := gloas.MatchingPayload(
-		beaconState,
-		beaconBlockRoot,
-		data.Slot,
-		uint64(data.CommitteeIndex),
-	)
-	if err != nil {
-		return nil, err
-	}
-	matchedSrcTgtHead = matchedSrcTgtHead && matchingPayload
 	if matchedSrcTgtHead && delay == cfg.MinAttestationInclusionDelay {
 		participatedFlags[headFlagIndex] = true
 	}

beacon-chain/core/altair/attestation_test.go

@@ -1,9 +1,7 @@
 package altair_test
 
 import (
-	"bytes"
 	"fmt"
-	"reflect"
 	"testing"
 
 	"github.com/OffchainLabs/go-bitfield"
@@ -558,7 +556,7 @@ func TestSetParticipationAndRewardProposer(t *testing.T) {
 
 			b, err := helpers.TotalActiveBalance(beaconState)
 			require.NoError(t, err)
-			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b, &ethpb.Attestation{})
+			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b)
 			require.NoError(t, err)
 
 			i, err := helpers.BeaconProposerIndex(t.Context(), st)
@@ -777,67 +775,11 @@ func TestAttestationParticipationFlagIndices(t *testing.T) {
 				headFlagIndex:   true,
 			},
 		},
-		{
-			name: "gloas same-slot committee index non-zero errors",
-			inputState: func() state.BeaconState {
-				stateSlot := primitives.Slot(5)
-				slot := primitives.Slot(3)
-				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
-				headRoot := bytes.Repeat([]byte{0xBB}, 32)
-				prevRoot := bytes.Repeat([]byte{0xCC}, 32)
-				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, prevRoot, 0, 0)
-			}(),
-			inputData: &ethpb.AttestationData{
-				Slot:            3,
-				CommitteeIndex:  1, // invalid for same-slot
-				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
-				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
-				Target: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  bytes.Repeat([]byte{0xAA}, 32),
-				},
-			},
-			inputDelay:           1,
-			participationIndices: nil,
-		},
-		{
-			name: "gloas payload availability matches committee index",
-			inputState: func() state.BeaconState {
-				stateSlot := primitives.Slot(5)
-				slot := primitives.Slot(3)
-				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
-				headRoot := bytes.Repeat([]byte{0xBB}, 32)
-				// Same prev root to make SameSlotAttestation false and use payload availability.
-				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, headRoot, 1, slot)
-			}(),
-			inputData: &ethpb.AttestationData{
-				Slot:            3,
-				CommitteeIndex:  1,
-				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
-				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
-				Target: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  bytes.Repeat([]byte{0xAA}, 32),
-				},
-			},
-			inputDelay: 1,
-			participationIndices: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: true,
-				headFlagIndex:   true,
-			},
-		},
 	}
 	for _, test := range tests {
 		flagIndices, err := altair.AttestationParticipationFlagIndices(test.inputState, test.inputData, test.inputDelay)
-		if test.participationIndices == nil {
-			require.ErrorContains(t, "committee index", err)
-			continue
-		}
 		require.NoError(t, err)
-		if !reflect.DeepEqual(test.participationIndices, flagIndices) {
-			t.Fatalf("unexpected participation indices: got %v want %v", flagIndices, test.participationIndices)
-		}
+		require.DeepEqual(t, test.participationIndices, flagIndices)
 	}
 }
 
@@ -916,61 +858,3 @@ func TestMatchingStatus(t *testing.T) {
 		require.Equal(t, test.matchedHead, head)
 	}
 }
-
-func buildGloasStateForFlags(t *testing.T, stateSlot, slot primitives.Slot, targetRoot, headRoot, prevRoot []byte, availabilityBit uint8, availabilitySlot primitives.Slot) state.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	blockRoots[0] = targetRoot
-	blockRoots[slot%cfg.SlotsPerHistoricalRoot] = headRoot
-	blockRoots[(slot-1)%cfg.SlotsPerHistoricalRoot] = prevRoot
-
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = make([]byte, fieldparams.RootLength)
-	}
-
-	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-	idx := availabilitySlot % cfg.SlotsPerHistoricalRoot
-	byteIndex := idx / 8
-	bitIndex := idx % 8
-	if availabilityBit == 1 {
-		execPayloadAvailability[byteIndex] |= 1 << bitIndex
-	}
-
-	checkpointRoot := bytes.Repeat([]byte{0xDD}, fieldparams.RootLength)
-	justified := &ethpb.Checkpoint{Root: checkpointRoot}
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: execPayloadAvailability,
-		CurrentJustifiedCheckpoint:   justified,
-		PreviousJustifiedCheckpoint:  justified,
-		Validators: []*ethpb.Validator{
-			{
-				EffectiveBalance:      cfg.MinActivationBalance,
-				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
-			},
-		},
-		Balances:               []uint64{cfg.MinActivationBalance},
-		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
-			Epoch:           0,
-		},
-	}
-
-	beaconState, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return beaconState
-}

beacon-chain/core/blocks/attestation.go

@@ -111,21 +111,10 @@ func VerifyAttestationNoVerifySignature(
 	var indexedAtt ethpb.IndexedAtt
 
 	if att.Version() >= version.Electra {
-		ci := att.GetData().CommitteeIndex
-		// Spec v1.7.0-alpha pseudocode:
-		//
-		//	# [Modified in Gloas:EIP7732]
-		//	assert data.index < 2
-		//
-		if beaconState.Version() >= version.Gloas {
-			if ci >= 2 {
-				return fmt.Errorf("incorrect committee index %d", ci)
-			}
-		} else {
-			if ci != 0 {
-				return errors.New("committee index must be 0 between Electra and Gloas forks")
-			}
+		if att.GetData().CommitteeIndex != 0 {
+			return errors.New("committee index must be 0 post-Electra")
 		}
+
 		aggBits := att.GetAggregationBits()
 		committeeIndices := att.CommitteeBitsVal().BitIndices()
 		committees := make([][]primitives.ValidatorIndex, len(committeeIndices))

beacon-chain/core/blocks/attestation_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"bytes"
 	"context"
 	"testing"
 
@@ -263,7 +262,7 @@ func TestVerifyAttestationNoVerifySignature_Electra(t *testing.T) {
 			CommitteeBits:   bitfield.NewBitvector64(),
 		}
 		err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
-		assert.ErrorContains(t, "committee index must be 0", err)
+		assert.ErrorContains(t, "committee index must be 0 post-Electra", err)
 	})
 	t.Run("index of committee too big", func(t *testing.T) {
 		aggBits := bitfield.NewBitlist(3)
@@ -315,75 +314,6 @@ func TestVerifyAttestationNoVerifySignature_Electra(t *testing.T) {
 	})
 }
 
-func TestVerifyAttestationNoVerifySignature_GloasCommitteeIndexLimit(t *testing.T) {
-	cfg := params.BeaconConfig()
-	stateSlot := cfg.MinAttestationInclusionDelay + 1
-
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range blockRoots {
-		blockRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = make([]byte, fieldparams.RootLength)
-	}
-
-	checkpointRoot := bytes.Repeat([]byte{0xAA}, fieldparams.RootLength)
-	justified := &ethpb.Checkpoint{Epoch: 0, Root: checkpointRoot}
-
-	gloasStateProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: make([]byte, cfg.SlotsPerHistoricalRoot/8),
-		CurrentJustifiedCheckpoint:   justified,
-		PreviousJustifiedCheckpoint:  justified,
-		Validators: []*ethpb.Validator{
-			{
-				EffectiveBalance:      cfg.MinActivationBalance,
-				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
-			},
-		},
-		Balances:               []uint64{cfg.MinActivationBalance},
-		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
-			Epoch:           0,
-		},
-	}
-
-	beaconState, err := state_native.InitializeFromProtoGloas(gloasStateProto)
-	require.NoError(t, err)
-
-	committeeBits := bitfield.NewBitvector64()
-	committeeBits.SetBitAt(0, true)
-	aggBits := bitfield.NewBitlist(1)
-	aggBits.SetBitAt(0, true)
-
-	att := &ethpb.AttestationElectra{
-		Data: &ethpb.AttestationData{
-			Slot:            0,
-			CommitteeIndex:  2, // invalid for Gloas (must be <2)
-			BeaconBlockRoot: blockRoots[0],
-			Source:          justified,
-			Target:          justified,
-		},
-		AggregationBits: aggBits,
-		CommitteeBits:   committeeBits,
-		Signature:       bytes.Repeat([]byte{0x00}, fieldparams.BLSSignatureLength),
-	}
-
-	err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
-	assert.ErrorContains(t, "incorrect committee index 2", err)
-}
-
 func TestConvertToIndexed_OK(t *testing.T) {
 	helpers.ClearCache()
 	validators := make([]*ethpb.Validator, 2*params.BeaconConfig().SlotsPerEpoch)
@@ -653,7 +583,6 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 }
 
 func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing.T) {
-	helpers.ClearCache()
 	ctx := t.Context()
 	numOfValidators := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))
 	validators := make([]*ethpb.Validator, numOfValidators)

beacon-chain/core/gloas/BUILD.bazel

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "attestation.go",
         "bid.go",
         "payload_attestation.go",
         "pending_payment.go",
@@ -27,7 +26,6 @@ go_library(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
@@ -36,7 +34,6 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
-        "attestation_test.go",
         "bid_test.go",
         "payload_attestation_test.go",
         "pending_payment_test.go",

beacon-chain/core/gloas/attestation.go

@@ -1,52 +0,0 @@
-package gloas
-
-import (
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/pkg/errors"
-)
-
-// MatchingPayload returns true if the attestation's committee index matches the expected payload index.
-//
-// For pre-Gloas forks, this always returns true.
-//
-// Spec v1.7.0-alpha (pseudocode):
-//
-//	# [New in Gloas:EIP7732]
-//	if is_attestation_same_slot(state, data):
-//	    assert data.index == 0
-//	    payload_matches = True
-//	else:
-//	    slot_index = data.slot % SLOTS_PER_HISTORICAL_ROOT
-//	    payload_index = state.execution_payload_availability[slot_index]
-//	    payload_matches = data.index == payload_index
-func MatchingPayload(
-	beaconState state.ReadOnlyBeaconState,
-	beaconBlockRoot [32]byte,
-	slot primitives.Slot,
-	committeeIndex uint64,
-) (bool, error) {
-	if beaconState.Version() < version.Gloas {
-		return true, nil
-	}
-
-	sameSlot, err := beaconState.IsAttestationSameSlot(beaconBlockRoot, slot)
-	if err != nil {
-		return false, errors.Wrap(err, "failed to get same slot attestation status")
-	}
-	if sameSlot {
-		if committeeIndex != 0 {
-			return false, fmt.Errorf("committee index %d for same slot attestation must be 0", committeeIndex)
-		}
-		return true, nil
-	}
-
-	executionPayloadAvail, err := beaconState.ExecutionPayloadAvailability(slot)
-	if err != nil {
-		return false, errors.Wrap(err, "failed to get execution payload availability status")
-	}
-	return executionPayloadAvail == committeeIndex, nil
-}

beacon-chain/core/gloas/attestation_test.go

@@ -1,110 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"testing"
-
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func buildStateWithBlockRoots(t *testing.T, stateSlot primitives.Slot, roots map[primitives.Slot][]byte) *state_native.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for slot, root := range roots {
-		blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
-	}
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:       stateSlot,
-		BlockRoots: blockRoots,
-	}
-
-	state, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return state.(*state_native.BeaconState)
-}
-
-func TestMatchingPayload(t *testing.T) {
-	t.Run("pre-gloas always true", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
-		require.NoError(t, err)
-
-		ok, err := MatchingPayload(stIface, [32]byte{}, 0, 123)
-		require.NoError(t, err)
-		require.Equal(t, true, ok)
-	})
-
-	t.Run("same slot requires committee index 0", func(t *testing.T) {
-		root := bytes.Repeat([]byte{0xAA}, 32)
-		state := buildStateWithBlockRoots(t, 6, map[primitives.Slot][]byte{
-			4: root,
-			3: bytes.Repeat([]byte{0xBB}, 32),
-		})
-
-		var rootArr [32]byte
-		copy(rootArr[:], root)
-
-		ok, err := MatchingPayload(state, rootArr, 4, 1)
-		require.ErrorContains(t, "committee index", err)
-		require.Equal(t, false, ok)
-	})
-
-	t.Run("same slot matches when committee index is 0", func(t *testing.T) {
-		root := bytes.Repeat([]byte{0xAA}, 32)
-		state := buildStateWithBlockRoots(t, 6, map[primitives.Slot][]byte{
-			4: root,
-			3: bytes.Repeat([]byte{0xBB}, 32),
-		})
-
-		var rootArr [32]byte
-		copy(rootArr[:], root)
-
-		ok, err := MatchingPayload(state, rootArr, 4, 0)
-		require.NoError(t, err)
-		require.Equal(t, true, ok)
-	})
-
-	t.Run("non same slot checks payload availability", func(t *testing.T) {
-		cfg := params.BeaconConfig()
-		root := bytes.Repeat([]byte{0xAA}, 32)
-		blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-		blockRoots[4%cfg.SlotsPerHistoricalRoot] = bytes.Repeat([]byte{0xCC}, 32)
-		blockRoots[3%cfg.SlotsPerHistoricalRoot] = bytes.Repeat([]byte{0xBB}, 32)
-
-		availability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-		slotIndex := uint64(4)
-		availability[slotIndex/8] = byte(1 << (slotIndex % 8))
-
-		stIface, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			Slot:                         6,
-			BlockRoots:                   blockRoots,
-			ExecutionPayloadAvailability: availability,
-			Fork: &ethpb.Fork{
-				CurrentVersion:  bytes.Repeat([]byte{0x66}, 4),
-				PreviousVersion: bytes.Repeat([]byte{0x66}, 4),
-				Epoch:           0,
-			},
-		})
-		require.NoError(t, err)
-		state := stIface.(*state_native.BeaconState)
-		require.Equal(t, version.Gloas, state.Version())
-
-		var rootArr [32]byte
-		copy(rootArr[:], root)
-
-		ok, err := MatchingPayload(state, rootArr, 4, 1)
-		require.NoError(t, err)
-		require.Equal(t, true, ok)
-
-		ok, err = MatchingPayload(state, rootArr, 4, 0)
-		require.NoError(t, err)
-		require.Equal(t, false, ok)
-	})
-}

beacon-chain/core/gloas/payload_attestation.go

@@ -156,6 +156,11 @@ func payloadCommittee(ctx context.Context, st state.ReadOnlyBeaconState, slot pr
 	return selected, nil
 }
 
+// PayloadTimelinessCommittee returns the payload timeliness committee for a given slot.
+func PayloadTimelinessCommittee(ctx context.Context, st state.ReadOnlyBeaconState, slot primitives.Slot) ([]primitives.ValidatorIndex, error) {
+	return payloadCommittee(ctx, st, slot)
+}
+
 // ptcSeed computes the seed for the payload timeliness committee.
 func ptcSeed(st state.ReadOnlyBeaconState, epoch primitives.Epoch, slot primitives.Slot) ([32]byte, error) {
 	seed, err := helpers.Seed(st, epoch, params.BeaconConfig().DomainPTCAttester)

beacon-chain/p2p/gossip_topic_mappings.go

@@ -25,6 +25,7 @@ var gossipTopicMappings = map[string]func() proto.Message{
 	LightClientOptimisticUpdateTopicFormat:    func() proto.Message { return &ethpb.LightClientOptimisticUpdateAltair{} },
 	LightClientFinalityUpdateTopicFormat:      func() proto.Message { return &ethpb.LightClientFinalityUpdateAltair{} },
 	DataColumnSubnetTopicFormat:               func() proto.Message { return &ethpb.DataColumnSidecar{} },
+	PayloadAttestationMessageTopicFormat:      func() proto.Message { return &ethpb.PayloadAttestationMessage{} },
 }
 
 // GossipTopicMappings is a function to return the assigned data type
@@ -144,4 +145,7 @@ func init() {
 
 	// Specially handle Fulu objects.
 	GossipTypeMapping[reflect.TypeFor[*ethpb.SignedBeaconBlockFulu]()] = BlockSubnetTopicFormat
+
+	// Payload attestation messages.
+	GossipTypeMapping[reflect.TypeFor[*ethpb.PayloadAttestationMessage]()] = PayloadAttestationMessageTopicFormat
 }

beacon-chain/p2p/topics.go

@@ -46,6 +46,8 @@ const (
 	GossipLightClientOptimisticUpdateMessage = "light_client_optimistic_update"
 	// GossipDataColumnSidecarMessage is the name for the data column sidecar message type.
 	GossipDataColumnSidecarMessage = "data_column_sidecar"
+	// GossipPayloadAttestationMessage is the name for the payload attestation message type.
+	GossipPayloadAttestationMessage = "payload_attestation_message"
 
 	// Topic Formats
 	//
@@ -75,6 +77,8 @@ const (
 	LightClientOptimisticUpdateTopicFormat = GossipProtocolAndDigest + GossipLightClientOptimisticUpdateMessage
 	// DataColumnSubnetTopicFormat is the topic format for the data column subnet.
 	DataColumnSubnetTopicFormat = GossipProtocolAndDigest + GossipDataColumnSidecarMessage + "_%d"
+	// PayloadAttestationMessageTopicFormat is the topic format for payload attestation messages.
+	PayloadAttestationMessageTopicFormat = GossipProtocolAndDigest + GossipPayloadAttestationMessage
 )
 
 // topic is a struct representing a single gossipsub topic.
@@ -148,6 +152,7 @@ func (s *Service) allTopics() []topic {
 	empty := [4]byte{0, 0, 0, 0} // empty digest for templates, replaced by real digests in per-fork copies.
 	templates := []topic{
 		newTopic(genesis, future, empty, GossipBlockMessage),
+		newTopic(genesis, future, empty, GossipPayloadAttestationMessage),
 		newTopic(genesis, future, empty, GossipAggregateAndProofMessage),
 		newTopic(genesis, future, empty, GossipExitMessage),
 		newTopic(genesis, future, empty, GossipProposerSlashingMessage),

beacon-chain/state/interfaces_gloas.go

@@ -13,7 +13,6 @@ type writeOnlyGloasFields interface {
 	RotateBuilderPendingPayments() error
 	AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal) error
 	UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val byte) error
-	UpdatePendingPaymentWeight(att ethpb.Att, indices []uint64, participatedFlags map[uint8]bool) error
 }
 
 type readOnlyGloasFields interface {
@@ -21,8 +20,5 @@ type readOnlyGloasFields interface {
 	IsActiveBuilder(primitives.BuilderIndex) (bool, error)
 	CanBuilderCoverBid(primitives.BuilderIndex, primitives.Gwei) (bool, error)
 	LatestBlockHash() ([32]byte, error)
-	IsAttestationSameSlot(blockRoot [32]byte, slot primitives.Slot) (bool, error)
-	BuilderPendingPayment(index uint64) (*ethpb.BuilderPendingPayment, error)
 	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
-	ExecutionPayloadAvailability(slot primitives.Slot) (uint64, error)
 }

beacon-chain/state/state-native/getters_gloas.go

@@ -1,16 +1,13 @@
 package state_native
 
 import (
-	"bytes"
 	"fmt"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/pkg/errors"
 )
 
 // LatestBlockHash returns the hash of the latest execution block.
@@ -29,45 +26,6 @@ func (b *BeaconState) LatestBlockHash() ([32]byte, error) {
 	return [32]byte(b.latestBlockHash), nil
 }
 
-// IsAttestationSameSlot checks if the attestation is for the same slot as the block root in the state.
-// Spec v1.7.0-alpha pseudocode:
-//
-//	is_attestation_same_slot(state, data):
-//	    if data.slot == 0:
-//	        return True
-//
-//	    blockroot = data.beacon_block_root
-//	    slot_blockroot = get_block_root_at_slot(state, data.slot)
-//	    prev_blockroot = get_block_root_at_slot(state, Slot(data.slot - 1))
-//
-//	    return blockroot == slot_blockroot and blockroot != prev_blockroot
-func (b *BeaconState) IsAttestationSameSlot(blockRoot [32]byte, slot primitives.Slot) (bool, error) {
-	if b.version < version.Gloas {
-		return false, errNotSupported("IsAttestationSameSlot", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if slot == 0 {
-		return true, nil
-	}
-
-	blockRootAtSlot, err := helpers.BlockRootAtSlot(b, slot)
-	if err != nil {
-		return false, errors.Wrapf(err, "block root at slot %d", slot)
-	}
-	matchingBlockRoot := bytes.Equal(blockRoot[:], blockRootAtSlot)
-
-	blockRootAtPrevSlot, err := helpers.BlockRootAtSlot(b, slot-1)
-	if err != nil {
-		return false, errors.Wrapf(err, "block root at slot %d", slot-1)
-	}
-	matchingPrevBlockRoot := bytes.Equal(blockRoot[:], blockRootAtPrevSlot)
-
-	return matchingBlockRoot && !matchingPrevBlockRoot, nil
-}
-
 // BuilderPubkey returns the builder pubkey at the provided index.
 func (b *BeaconState) BuilderPubkey(builderIndex primitives.BuilderIndex) ([fieldparams.BLSPubkeyLength]byte, error) {
 	if b.version < version.Gloas {
@@ -198,36 +156,3 @@ func (b *BeaconState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment,
 
 	return b.builderPendingPaymentsVal(), nil
 }
-
-// BuilderPendingPayment returns the builder pending payment for the given index.
-func (b *BeaconState) BuilderPendingPayment(index uint64) (*ethpb.BuilderPendingPayment, error) {
-	if b.version < version.Gloas {
-		return nil, errNotSupported("BuilderPendingPayment", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if index >= uint64(len(b.builderPendingPayments)) {
-		return nil, fmt.Errorf("builder pending payment index %d out of range (len=%d)", index, len(b.builderPendingPayments))
-	}
-	return ethpb.CopyBuilderPendingPayment(b.builderPendingPayments[index]), nil
-}
-
-// ExecutionPayloadAvailability returns the execution payload availability bit for the given slot.
-func (b *BeaconState) ExecutionPayloadAvailability(slot primitives.Slot) (uint64, error) {
-	if b.version < version.Gloas {
-		return 0, errNotSupported("ExecutionPayloadAvailability", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	slotIndex := slot % params.BeaconConfig().SlotsPerHistoricalRoot
-	byteIndex := slotIndex / 8
-	bitIndex := slotIndex % 8
-
-	bit := (b.executionPayloadAvailability[byteIndex] >> bitIndex) & 1
-
-	return uint64(bit), nil
-}

beacon-chain/state/state-native/getters_gloas_test.go

@@ -44,92 +44,6 @@ func TestLatestBlockHash(t *testing.T) {
 	})
 }
 
-func TestIsAttestationSameSlot(t *testing.T) {
-	buildStateWithBlockRoots := func(t *testing.T, stateSlot primitives.Slot, roots map[primitives.Slot][]byte) *state_native.BeaconState {
-		t.Helper()
-
-		cfg := params.BeaconConfig()
-		blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-		for slot, root := range roots {
-			blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
-		}
-
-		stIface, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			Slot:       stateSlot,
-			BlockRoots: blockRoots,
-		})
-		require.NoError(t, err)
-		return stIface.(*state_native.BeaconState)
-	}
-
-	rootA := bytes.Repeat([]byte{0xAA}, 32)
-	rootB := bytes.Repeat([]byte{0xBB}, 32)
-	rootC := bytes.Repeat([]byte{0xCC}, 32)
-
-	tests := []struct {
-		name      string
-		stateSlot primitives.Slot
-		slot      primitives.Slot
-		blockRoot []byte
-		roots     map[primitives.Slot][]byte
-		want      bool
-	}{
-		{
-			name:      "slot zero always true",
-			stateSlot: 1,
-			slot:      0,
-			blockRoot: rootA,
-			roots:     map[primitives.Slot][]byte{},
-			want:      true,
-		},
-		{
-			name:      "matching current different previous",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootA,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootB,
-			},
-			want: true,
-		},
-		{
-			name:      "matching current same previous",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootA,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootA,
-			},
-			want: false,
-		},
-		{
-			name:      "non matching current",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootC,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootB,
-			},
-			want: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			st := buildStateWithBlockRoots(t, tt.stateSlot, tt.roots)
-			var rootArr [32]byte
-			copy(rootArr[:], tt.blockRoot)
-
-			got, err := st.IsAttestationSameSlot(rootArr, tt.slot)
-			require.NoError(t, err)
-			require.Equal(t, tt.want, got)
-		})
-	}
-}
-
 func TestBuilderPubkey(t *testing.T) {
 	t.Run("returns error before gloas", func(t *testing.T) {
 		stIface, _ := util.DeterministicGenesisState(t, 1)
@@ -252,79 +166,3 @@ func TestBuilderPendingPayments_UnsupportedVersion(t *testing.T) {
 	_, err = st.BuilderPendingPayments()
 	require.ErrorContains(t, "BuilderPendingPayments", err)
 }
-
-func TestBuilderPendingPayment(t *testing.T) {
-	t.Run("returns copy", func(t *testing.T) {
-		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-		payments := make([]*ethpb.BuilderPendingPayment, 2*slotsPerEpoch)
-		target := uint64(slotsPerEpoch + 1)
-		payments[target] = &ethpb.BuilderPendingPayment{Weight: 10}
-
-		st, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
-			BuilderPendingPayments: payments,
-		})
-		require.NoError(t, err)
-
-		payment, err := st.BuilderPendingPayment(target)
-		require.NoError(t, err)
-
-		// mutate returned copy
-		payment.Weight = 99
-
-		original, err := st.BuilderPendingPayment(target)
-		require.NoError(t, err)
-		require.Equal(t, uint64(10), uint64(original.Weight))
-	})
-
-	t.Run("unsupported version", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
-		require.NoError(t, err)
-		st := stIface.(*state_native.BeaconState)
-
-		_, err = st.BuilderPendingPayment(0)
-		require.ErrorContains(t, "BuilderPendingPayment", err)
-	})
-
-	t.Run("out of range", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
-			BuilderPendingPayments: []*ethpb.BuilderPendingPayment{},
-		})
-		require.NoError(t, err)
-
-		_, err = stIface.BuilderPendingPayment(0)
-		require.ErrorContains(t, "out of range", err)
-	})
-}
-
-func TestExecutionPayloadAvailability(t *testing.T) {
-	t.Run("unsupported version", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
-		require.NoError(t, err)
-		st := stIface.(*state_native.BeaconState)
-
-		_, err = st.ExecutionPayloadAvailability(0)
-		require.ErrorContains(t, "ExecutionPayloadAvailability", err)
-	})
-
-	t.Run("reads expected bit", func(t *testing.T) {
-		// Ensure the backing slice is large enough.
-		availability := make([]byte, params.BeaconConfig().SlotsPerHistoricalRoot/8)
-
-		// Pick a slot and set its corresponding bit.
-		slot := primitives.Slot(9) // byteIndex=1, bitIndex=1
-		availability[1] = 0b00000010
-
-		stIface, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
-			ExecutionPayloadAvailability: availability,
-		})
-		require.NoError(t, err)
-
-		bit, err := stIface.ExecutionPayloadAvailability(slot)
-		require.NoError(t, err)
-		require.Equal(t, uint64(1), bit)
-
-		otherBit, err := stIface.ExecutionPayloadAvailability(8)
-		require.NoError(t, err)
-		require.Equal(t, uint64(0), otherBit)
-	})
-}

beacon-chain/state/state-native/setters_gloas.go

@@ -10,7 +10,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
 )
 
 // RotateBuilderPendingPayments rotates the queue by dropping slots per epoch payments from the
@@ -162,123 +161,3 @@ func (b *BeaconState) UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val
 	b.markFieldAsDirty(types.ExecutionPayloadAvailability)
 	return nil
 }
-
-// UpdatePendingPaymentWeight updates the builder pending payment weight based on attestation participation.
-//
-// This is a no-op for pre-Gloas forks.
-//
-// Spec v1.7.0-alpha pseudocode:
-//
-//	if data.target.epoch == get_current_epoch(state):
-//	    current_epoch_target = True
-//	    epoch_participation = state.current_epoch_participation
-//	    payment = state.builder_pending_payments[SLOTS_PER_EPOCH + data.slot % SLOTS_PER_EPOCH]
-//	else:
-//	    current_epoch_target = False
-//	    epoch_participation = state.previous_epoch_participation
-//	    payment = state.builder_pending_payments[data.slot % SLOTS_PER_EPOCH]
-//
-//	proposer_reward_numerator = 0
-//	for index in get_attesting_indices(state, attestation):
-//	    will_set_new_flag = False
-//	    for flag_index, weight in enumerate(PARTICIPATION_FLAG_WEIGHTS):
-//	        if flag_index in participation_flag_indices and not has_flag(epoch_participation[index], flag_index):
-//	            epoch_participation[index] = add_flag(epoch_participation[index], flag_index)
-//	            proposer_reward_numerator += get_base_reward(state, index) * weight
-//	            # [New in Gloas:EIP7732]
-//	            will_set_new_flag = True
-//	    if (
-//	        will_set_new_flag
-//	        and is_attestation_same_slot(state, data)
-//	        and payment.withdrawal.amount > 0
-//	    ):
-//	        payment.weight += state.validators[index].effective_balance
-//	if current_epoch_target:
-//	    state.builder_pending_payments[SLOTS_PER_EPOCH + data.slot % SLOTS_PER_EPOCH] = payment
-//	else:
-//	    state.builder_pending_payments[data.slot % SLOTS_PER_EPOCH] = payment
-func (b *BeaconState) UpdatePendingPaymentWeight(att ethpb.Att, indices []uint64, participatedFlags map[uint8]bool) error {
-	var (
-		paymentSlot    primitives.Slot
-		currentPayment *ethpb.BuilderPendingPayment
-		weight         primitives.Gwei
-	)
-
-	early, err := func() (bool, error) {
-		b.lock.RLock()
-		defer b.lock.RUnlock()
-
-		if b.version < version.Gloas {
-			return true, nil
-		}
-
-		data := att.GetData()
-		var beaconBlockRoot [32]byte
-		copy(beaconBlockRoot[:], data.BeaconBlockRoot)
-		sameSlot, err := b.IsAttestationSameSlot(beaconBlockRoot, data.Slot)
-		if err != nil {
-			return false, err
-		}
-		if !sameSlot {
-			return true, nil
-		}
-
-		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-		var epochParticipation []byte
-
-		if data.Target != nil && data.Target.Epoch == slots.ToEpoch(b.slot) {
-			paymentSlot = slotsPerEpoch + (data.Slot % slotsPerEpoch)
-			epochParticipation = b.currentEpochParticipation
-		} else {
-			paymentSlot = data.Slot % slotsPerEpoch
-			epochParticipation = b.previousEpochParticipation
-		}
-
-		if uint64(paymentSlot) >= uint64(len(b.builderPendingPayments)) {
-			return false, fmt.Errorf("builder pending payments index %d out of range (len=%d)", paymentSlot, len(b.builderPendingPayments))
-		}
-		currentPayment = b.builderPendingPayments[paymentSlot]
-		if currentPayment.Withdrawal.Amount == 0 {
-			return true, nil
-		}
-
-		cfg := params.BeaconConfig()
-		flagIndices := []uint8{cfg.TimelySourceFlagIndex, cfg.TimelyTargetFlagIndex, cfg.TimelyHeadFlagIndex}
-		for _, idx := range indices {
-			if idx >= uint64(len(epochParticipation)) {
-				return false, fmt.Errorf("index %d exceeds participation length %d", idx, len(epochParticipation))
-			}
-			participation := epochParticipation[idx]
-			for _, f := range flagIndices {
-				if !participatedFlags[f] {
-					continue
-				}
-				if participation&(1<<f) == 0 {
-					v, err := b.validatorAtIndexReadOnly(primitives.ValidatorIndex(idx))
-					if err != nil {
-						return false, fmt.Errorf("validator at index %d: %w", idx, err)
-					}
-					weight += primitives.Gwei(v.EffectiveBalance())
-					break
-				}
-			}
-		}
-		return false, nil
-	}()
-	if err != nil {
-		return err
-	}
-	if early || weight == 0 {
-		return nil
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	newPayment := ethpb.CopyBuilderPendingPayment(currentPayment)
-	newPayment.Weight += weight
-	b.builderPendingPayments[paymentSlot] = newPayment
-	b.markFieldAsDirty(types.BuilderPendingPayments)
-
-	return nil
-}

beacon-chain/state/state-native/setters_gloas_test.go

@@ -11,7 +11,6 @@ import (
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
 )
 
 type testExecutionPayloadBid struct {
@@ -182,99 +181,6 @@ func TestClearBuilderPendingPayment(t *testing.T) {
 	})
 }
 
-func TestUpdatePendingPaymentWeight(t *testing.T) {
-	cfg := params.BeaconConfig()
-	slotsPerEpoch := cfg.SlotsPerEpoch
-	slot := primitives.Slot(4)
-	stateSlot := slot + 1
-	stateEpoch := slots.ToEpoch(stateSlot)
-
-	rootA := bytes.Repeat([]byte{0xAA}, 32)
-	rootB := bytes.Repeat([]byte{0xBB}, 32)
-
-	tests := []struct {
-		name          string
-		targetEpoch   primitives.Epoch
-		blockRoot     []byte
-		initialAmount primitives.Gwei
-		initialWeight primitives.Gwei
-		wantWeight    primitives.Gwei
-	}{
-		{
-			name:          "same slot current epoch adds weight",
-			targetEpoch:   stateEpoch,
-			blockRoot:     rootA,
-			initialAmount: 1,
-			initialWeight: 0,
-			wantWeight:    primitives.Gwei(cfg.MinActivationBalance),
-		},
-		{
-			name:          "same slot zero amount no weight change",
-			targetEpoch:   stateEpoch,
-			blockRoot:     rootA,
-			initialAmount: 0,
-			initialWeight: 5,
-			wantWeight:    5,
-		},
-		{
-			name:          "non matching block root no change",
-			targetEpoch:   stateEpoch,
-			blockRoot:     rootB,
-			initialAmount: 1,
-			initialWeight: 7,
-			wantWeight:    7,
-		},
-		{
-			name:          "previous epoch target uses earlier slot",
-			targetEpoch:   stateEpoch - 1,
-			blockRoot:     rootA,
-			initialAmount: 1,
-			initialWeight: 0,
-			wantWeight:    primitives.Gwei(cfg.MinActivationBalance),
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var paymentIdx int
-			if tt.targetEpoch == stateEpoch {
-				paymentIdx = int(slotsPerEpoch + (slot % slotsPerEpoch))
-			} else {
-				paymentIdx = int(slot % slotsPerEpoch)
-			}
-			state := buildGloasStateForPaymentWeightTest(t, stateSlot, paymentIdx, tt.initialAmount, tt.initialWeight, map[primitives.Slot][]byte{
-				slot:     tt.blockRoot,
-				slot - 1: rootB,
-			})
-
-			att := &ethpb.Attestation{
-				Data: &ethpb.AttestationData{
-					Slot:            slot,
-					CommitteeIndex:  0,
-					BeaconBlockRoot: tt.blockRoot,
-					Source:          &ethpb.Checkpoint{},
-					Target: &ethpb.Checkpoint{
-						Epoch: tt.targetEpoch,
-					},
-				},
-			}
-
-			participatedFlags := map[uint8]bool{
-				cfg.TimelySourceFlagIndex: true,
-				cfg.TimelyTargetFlagIndex: true,
-				cfg.TimelyHeadFlagIndex:   true,
-			}
-			indices := []uint64{0}
-
-			require.NoError(t, state.UpdatePendingPaymentWeight(att, indices, participatedFlags))
-
-			payment, err := state.BuilderPendingPayment(uint64(paymentIdx))
-			require.NoError(t, err)
-			require.Equal(t, tt.wantWeight, payment.Weight)
-		})
-	}
-}
-
 func TestRotateBuilderPendingPayments(t *testing.T) {
 	totalPayments := 2 * params.BeaconConfig().SlotsPerEpoch
 	payments := make([]*ethpb.BuilderPendingPayment, totalPayments)
@@ -412,79 +318,6 @@ func TestUpdateExecutionPayloadAvailabilityAtIndex_OutOfRange(t *testing.T) {
 	}
 }
 
-func buildGloasStateForPaymentWeightTest(
-	t *testing.T,
-	stateSlot primitives.Slot,
-	paymentIdx int,
-	amount primitives.Gwei,
-	weight primitives.Gwei,
-	roots map[primitives.Slot][]byte,
-) *BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for slot, root := range roots {
-		blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
-	}
-
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = bytes.Repeat([]byte{0x44}, 32)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = bytes.Repeat([]byte{0x55}, 32)
-	}
-
-	validator := &ethpb.Validator{
-		PublicKey:             bytes.Repeat([]byte{0x01}, 48),
-		WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x02}, 31)...),
-		EffectiveBalance:      cfg.MinActivationBalance,
-	}
-
-	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
-	for i := range payments {
-		payments[i] = &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		}
-	}
-	payments[paymentIdx] = &ethpb.BuilderPendingPayment{
-		Weight: weight,
-		Withdrawal: &ethpb.BuilderPendingWithdrawal{
-			FeeRecipient: make([]byte, 20),
-			Amount:       amount,
-		},
-	}
-
-	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x33}, 32),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: execPayloadAvailability,
-		Validators:                   []*ethpb.Validator{validator},
-		Balances:                     []uint64{cfg.MinActivationBalance},
-		CurrentEpochParticipation:    []byte{0},
-		PreviousEpochParticipation:   []byte{0},
-		BuilderPendingPayments:       payments,
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x66}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x66}, 4),
-			Epoch:           0,
-		},
-	}
-
-	statePb, err := InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return statePb.(*BeaconState)
-}
-
 func newGloasStateWithAvailability(t *testing.T, availability []byte) *BeaconState {
 	t.Helper()
 

beacon-chain/sync/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
         "metrics.go",
         "once.go",
         "options.go",
+        "payload_attestations.go",
         "pending_attestations_queue.go",
         "pending_blocks_queue.go",
         "rate_limiter.go",
@@ -113,6 +114,7 @@ go_library(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
+        "//consensus-types/epbs/payload-attestation:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",
@@ -177,6 +179,7 @@ go_test(
         "fork_watcher_test.go",
         "kzg_batch_verifier_test.go",
         "once_test.go",
+        "payload_attestations_test.go",
         "pending_attestations_queue_bucket_test.go",
         "pending_attestations_queue_test.go",
         "pending_blocks_queue_test.go",
@@ -263,6 +266,7 @@ go_test(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
+        "//consensus-types/epbs/payload-attestation:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",

beacon-chain/sync/options.go

@@ -207,6 +207,13 @@ func WithTrackedValidatorsCache(c *cache.TrackedValidatorsCache) Option {
 	}
 }
 
+func WithPayloadAttestationCache(r *cache.PayloadAttestationCache) Option {
+	return func(s *Service) error {
+		s.payloadAttestationCache = r
+		return nil
+	}
+}
+
 // WithSlasherEnabled configures the sync package to support slashing detection.
 func WithSlasherEnabled(enabled bool) Option {
 	return func(s *Service) error {

beacon-chain/sync/payload_attestations.go

@@ -0,0 +1,94 @@
+package sync
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/verification"
+	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/epbs/payload-attestation"
+	"github.com/OffchainLabs/prysm/v7/monitoring/tracing"
+	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/pkg/errors"
+	"google.golang.org/protobuf/proto"
+)
+
+var (
+	errAlreadySeenPayloadAttestation = errors.New("payload attestation already seen for validator index")
+)
+
+func (s *Service) validatePayloadAttestation(ctx context.Context, pid peer.ID, msg *pubsub.Message) (pubsub.ValidationResult, error) {
+	if pid == s.cfg.p2p.PeerID() {
+		return pubsub.ValidationAccept, nil
+	}
+	if s.cfg.initialSync.Syncing() {
+		return pubsub.ValidationIgnore, nil
+	}
+	ctx, span := trace.StartSpan(ctx, "sync.validatePayloadAttestation")
+	defer span.End()
+	if msg.Topic == nil {
+		return pubsub.ValidationReject, p2p.ErrInvalidTopic
+	}
+	m, err := s.decodePubsubMessage(msg)
+	if err != nil {
+		tracing.AnnotateError(span, err)
+		return pubsub.ValidationReject, err
+	}
+	att, ok := m.(*eth.PayloadAttestationMessage)
+	if !ok {
+		return pubsub.ValidationReject, errWrongMessage
+	}
+	pa, err := payloadattestation.NewReadOnly(att)
+	if err != nil {
+		log.WithError(err).Error("Failed to create read only payload attestation")
+		return pubsub.ValidationIgnore, err
+	}
+	v := s.newPayloadAttestationVerifier(pa, verification.GossipPayloadAttestationMessageRequirements)
+
+	if err := v.VerifyCurrentSlot(); err != nil {
+		return pubsub.ValidationIgnore, err
+	}
+
+	if err := v.VerifyPayloadStatus(); err != nil {
+		return pubsub.ValidationReject, err
+	}
+
+	if err := v.VerifyBlockRootSeen(s.hasBadBlock); err != nil {
+		return pubsub.ValidationIgnore, err
+	}
+
+	if err := v.VerifyBlockRootValid(s.hasBadBlock); err != nil {
+		return pubsub.ValidationReject, err
+	}
+
+	st, err := s.cfg.chain.HeadState(ctx)
+	if err != nil {
+		return pubsub.ValidationIgnore, err
+	}
+
+	if err := v.VerifyValidatorInPTC(ctx, st); err != nil {
+		return pubsub.ValidationReject, err
+	}
+
+	if err := v.VerifySignature(st); err != nil {
+		return pubsub.ValidationReject, err
+	}
+
+	if s.payloadAttestationCache.Seen(pa.BeaconBlockRoot(), uint64(pa.ValidatorIndex())) {
+		return pubsub.ValidationIgnore, errAlreadySeenPayloadAttestation
+	}
+
+	msg.ValidatorData = att
+
+	return pubsub.ValidationAccept, nil
+}
+
+func (s *Service) payloadAttestationSubscriber(ctx context.Context, msg proto.Message) error {
+	a, ok := msg.(*eth.PayloadAttestationMessage)
+	if !ok {
+		return errWrongMessage
+	}
+	return s.cfg.chain.ReceivePayloadAttestationMessage(ctx, a)
+}

beacon-chain/sync/payload_attestations_test.go

@@ -0,0 +1,172 @@
+package sync
+
+import (
+	"bytes"
+	"context"
+	"reflect"
+	"testing"
+	"time"
+
+	mock "github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/testing"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
+	p2ptest "github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/testing"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
+	mockSync "github.com/OffchainLabs/prysm/v7/beacon-chain/sync/initial-sync/testing"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/verification"
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/epbs/payload-attestation"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	pb "github.com/libp2p/go-libp2p-pubsub/pb"
+	"github.com/pkg/errors"
+)
+
+func TestValidatePayloadAttestationMessage_IncorrectTopic(t *testing.T) {
+	ctx := context.Background()
+	p := p2ptest.NewTestP2P(t)
+	chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0)}
+	s := &Service{
+		payloadAttestationCache: &cache.PayloadAttestationCache{},
+		cfg:                     &config{chain: chainService, p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}}
+
+	msg := util.HydratePayloadAttestation(&ethpb.PayloadAttestation{}) // Using payload attestation for message should fail.
+	buf := new(bytes.Buffer)
+	_, err := p.Encoding().EncodeGossip(buf, msg)
+	require.NoError(t, err)
+
+	topic := p2p.GossipTypeMapping[reflect.TypeFor[*ethpb.PayloadAttestation]()]
+	digest, err := s.currentForkDigest()
+	require.NoError(t, err)
+	topic = s.addDigestToTopic(topic, digest)
+
+	result, err := s.validatePayloadAttestation(ctx, "", &pubsub.Message{
+		Message: &pb.Message{
+			Data:  buf.Bytes(),
+			Topic: &topic,
+		}})
+	require.ErrorContains(t, "extraction failed for topic", err)
+	require.Equal(t, result, pubsub.ValidationReject)
+}
+
+func TestValidatePayloadAttestationMessage_ErrorPathsWithMock(t *testing.T) {
+	tests := []struct {
+		error    error
+		verifier verification.NewPayloadAttestationMsgVerifier
+		result   pubsub.ValidationResult
+	}{
+		{
+			error: errors.New("incorrect slot"),
+			verifier: func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
+				return &verification.MockPayloadAttestation{ErrIncorrectPayloadAttSlot: errors.New("incorrect slot")}
+			},
+			result: pubsub.ValidationIgnore,
+		},
+		{
+			error: errors.New("incorrect status"),
+			verifier: func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
+				return &verification.MockPayloadAttestation{ErrIncorrectPayloadAttStatus: errors.New("incorrect status")}
+			},
+			result: pubsub.ValidationReject,
+		},
+		{
+			error: errors.New("block root seen"),
+			verifier: func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
+				return &verification.MockPayloadAttestation{ErrPayloadAttBlockRootNotSeen: errors.New("block root seen")}
+			},
+			result: pubsub.ValidationIgnore,
+		},
+		{
+			error: errors.New("block root invalid"),
+			verifier: func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
+				return &verification.MockPayloadAttestation{ErrPayloadAttBlockRootInvalid: errors.New("block root invalid")}
+			},
+			result: pubsub.ValidationReject,
+		},
+		{
+			error: errors.New("validator not in PTC"),
+			verifier: func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
+				return &verification.MockPayloadAttestation{ErrIncorrectPayloadAttValidator: errors.New("validator not in PTC")}
+			},
+			result: pubsub.ValidationReject,
+		},
+		{
+			error: errors.New("incorrect signature"),
+			verifier: func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
+				return &verification.MockPayloadAttestation{ErrInvalidMessageSignature: errors.New("incorrect signature")}
+			},
+			result: pubsub.ValidationReject,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.error.Error(), func(t *testing.T) {
+			ctx := context.Background()
+			p := p2ptest.NewTestP2P(t)
+			chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0)}
+			s := &Service{
+				payloadAttestationCache: &cache.PayloadAttestationCache{},
+				cfg:                     &config{chain: chainService, p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}}
+			s.newPayloadAttestationVerifier = tt.verifier
+
+			msg := newPayloadAttestationMessage()
+			buf := new(bytes.Buffer)
+			_, err := p.Encoding().EncodeGossip(buf, msg)
+			require.NoError(t, err)
+
+			topic := p2p.GossipTypeMapping[reflect.TypeFor[*ethpb.PayloadAttestationMessage]()]
+			digest, err := s.currentForkDigest()
+			require.NoError(t, err)
+			topic = s.addDigestToTopic(topic, digest)
+
+			result, err := s.validatePayloadAttestation(ctx, "", &pubsub.Message{
+				Message: &pb.Message{
+					Data:  buf.Bytes(),
+					Topic: &topic,
+				}})
+
+			require.ErrorContains(t, tt.error.Error(), err)
+			require.Equal(t, result, tt.result)
+		})
+	}
+}
+
+func TestValidatePayloadAttestationMessage_Accept(t *testing.T) {
+	ctx := context.Background()
+	p := p2ptest.NewTestP2P(t)
+	chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0)}
+	s := &Service{
+		payloadAttestationCache: &cache.PayloadAttestationCache{},
+		cfg:                     &config{chain: chainService, p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}}
+	s.newPayloadAttestationVerifier = func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
+		return &verification.MockPayloadAttestation{}
+	}
+
+	msg := newPayloadAttestationMessage()
+	buf := new(bytes.Buffer)
+	_, err := p.Encoding().EncodeGossip(buf, msg)
+	require.NoError(t, err)
+
+	topic := p2p.GossipTypeMapping[reflect.TypeFor[*ethpb.PayloadAttestationMessage]()]
+	digest, err := s.currentForkDigest()
+	require.NoError(t, err)
+	topic = s.addDigestToTopic(topic, digest)
+
+	result, err := s.validatePayloadAttestation(ctx, "", &pubsub.Message{
+		Message: &pb.Message{
+			Data:  buf.Bytes(),
+			Topic: &topic,
+		}})
+	require.NoError(t, err)
+	require.Equal(t, result, pubsub.ValidationAccept)
+}
+
+func newPayloadAttestationMessage() *ethpb.PayloadAttestationMessage {
+	return &ethpb.PayloadAttestationMessage{
+		ValidatorIndex: 0,
+		Data:           util.HydratePayloadAttestationData(&ethpb.PayloadAttestationData{Slot: 1}),
+		Signature:      make([]byte, fieldparams.BLSSignatureLength),
+	}
+}

beacon-chain/sync/service.go

@@ -37,6 +37,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/epbs/payload-attestation"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	leakybucket "github.com/OffchainLabs/prysm/v7/container/leaky-bucket"
@@ -121,6 +122,7 @@ type blockchainService interface {
 	blockchain.FinalizationFetcher
 	blockchain.ForkFetcher
 	blockchain.AttestationReceiver
+	blockchain.PayloadAttestationReceiver
 	blockchain.TimeFetcher
 	blockchain.GenesisFetcher
 	blockchain.CanonicalFetcher
@@ -173,6 +175,7 @@ type Service struct {
 	verifierWaiter                   *verification.InitializerWaiter
 	newBlobVerifier                  verification.NewBlobVerifier
 	newColumnsVerifier               verification.NewDataColumnsVerifier
+	newPayloadAttestationVerifier    verification.NewPayloadAttestationMsgVerifier
 	columnSidecarsExecSingleFlight   singleflight.Group
 	reconstructionSingleFlight       singleflight.Group
 	availableBlocker                 coverage.AvailableBlocker
@@ -182,6 +185,7 @@ type Service struct {
 	slasherEnabled                   bool
 	lcStore                          *lightClient.Store
 	dataColumnLogCh                  chan dataColumnLogEntry
+	payloadAttestationCache          *cache.PayloadAttestationCache
 	digestActions                    perDigestSet
 	subscriptionSpawner              func(func()) // see Service.spawn for details
 }
@@ -190,15 +194,16 @@ type Service struct {
 func NewService(ctx context.Context, opts ...Option) *Service {
 	ctx, cancel := context.WithCancel(ctx)
 	r := &Service{
-		ctx:                   ctx,
-		cancel:                cancel,
-		chainStarted:          abool.New(),
-		cfg:                   &config{clock: startup.NewClock(time.Unix(0, 0), [32]byte{})},
-		slotToPendingBlocks:   gcache.New(pendingBlockExpTime /* exp time */, 0 /* disable janitor */),
-		seenPendingBlocks:     make(map[[32]byte]bool),
-		blkRootToPendingAtts:  make(map[[32]byte][]any),
-		dataColumnLogCh:       make(chan dataColumnLogEntry, 1000),
-		reconstructionRandGen: rand.NewGenerator(),
+		ctx:                     ctx,
+		cancel:                  cancel,
+		chainStarted:            abool.New(),
+		cfg:                     &config{clock: startup.NewClock(time.Unix(0, 0), [32]byte{})},
+		slotToPendingBlocks:     gcache.New(pendingBlockExpTime /* exp time */, 0 /* disable janitor */),
+		seenPendingBlocks:       make(map[[32]byte]bool),
+		blkRootToPendingAtts:    make(map[[32]byte][]any),
+		dataColumnLogCh:         make(chan dataColumnLogEntry, 1000),
+		reconstructionRandGen:   rand.NewGenerator(),
+		payloadAttestationCache: &cache.PayloadAttestationCache{},
 	}
 
 	for _, opt := range opts {
@@ -250,6 +255,12 @@ func newDataColumnsVerifierFromInitializer(ini *verification.Initializer) verifi
 	}
 }
 
+func newPayloadAttestationMessageFromInitializer(ini *verification.Initializer) verification.NewPayloadAttestationMsgVerifier {
+	return func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
+		return ini.NewPayloadAttestationMsgVerifier(pa, reqs)
+	}
+}
+
 // Start the regular sync service.
 func (s *Service) Start() {
 	v, err := s.verifierWaiter.WaitForInitializer(s.ctx)
@@ -259,6 +270,7 @@ func (s *Service) Start() {
 	}
 	s.newBlobVerifier = newBlobVerifierFromInitializer(v)
 	s.newColumnsVerifier = newDataColumnsVerifierFromInitializer(v)
+	s.newPayloadAttestationVerifier = newPayloadAttestationMessageFromInitializer(v)
 
 	go s.verifierRoutine()
 	go s.startDiscoveryAndSubscriptions()

beacon-chain/verification/BUILD.bazel

@@ -7,20 +7,25 @@ go_library(
         "blob.go",
         "cache.go",
         "data_column.go",
+        "epbs.go",
         "error.go",
         "fake.go",
         "filesystem.go",
         "initializer.go",
+        "initializer_epbs.go",
         "interface.go",
         "log.go",
         "metrics.go",
         "mock.go",
+        "payload_attestation.go",
+        "payload_attestation_mock.go",
         "result.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/verification",
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/blockchain/kzg:go_default_library",
+        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
@@ -32,6 +37,7 @@ go_library(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
+        "//consensus-types/epbs/payload-attestation:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/verification/epbs.go

@@ -0,0 +1,24 @@
+package verification
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/epbs/payload-attestation"
+)
+
+// PayloadAttestationMsgVerifier defines the methods implemented by the ROPayloadAttestation.
+type PayloadAttestationMsgVerifier interface {
+	VerifyCurrentSlot() error
+	VerifyPayloadStatus() error
+	VerifyBlockRootSeen(func([32]byte) bool) error
+	VerifyBlockRootValid(func([32]byte) bool) error
+	VerifyValidatorInPTC(context.Context, state.BeaconState) error
+	VerifySignature(state.BeaconState) error
+	VerifiedPayloadAttestation() (payloadattestation.VerifiedROMessage, error)
+	SatisfyRequirement(Requirement)
+}
+
+// NewPayloadAttestationMsgVerifier is a function signature that can be used by code that needs to be
+// able to mock Initializer.NewPayloadAttestationMsgVerifier without complex setup.
+type NewPayloadAttestationMsgVerifier func(pa payloadattestation.ROMessage, reqs []Requirement) PayloadAttestationMsgVerifier

beacon-chain/verification/initializer_epbs.go

@@ -0,0 +1,15 @@
+package verification
+
+import (
+	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/epbs/payload-attestation"
+)
+
+// NewPayloadAttestationMsgVerifier creates a PayloadAttestationMsgVerifier for a single payload attestation message,
+// with the given set of requirements.
+func (ini *Initializer) NewPayloadAttestationMsgVerifier(pa payloadattestation.ROMessage, reqs []Requirement) *PayloadAttMsgVerifier {
+	return &PayloadAttMsgVerifier{
+		sharedResources: ini.shared,
+		results:         newResults(reqs...),
+		pa:              pa,
+	}
+}

beacon-chain/verification/payload_attestation.go

@@ -0,0 +1,218 @@
+package verification
+
+import (
+	"context"
+	"fmt"
+	"slices"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/epbs/payload-attestation"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+)
+
+// RequirementList defines a list of requirements.
+type RequirementList []Requirement
+
+const (
+	RequireCurrentSlot Requirement = iota
+	RequireMessageNotSeen
+	RequireKnownPayloadStatus
+	RequireValidatorInPTC
+	RequireBlockRootSeen
+	RequireBlockRootValid
+	RequireSignatureValid
+)
+
+// PayloadAttGossipRequirements defines the list of requirements for gossip payload attestation messages.
+var PayloadAttGossipRequirements = []Requirement{
+	RequireCurrentSlot,
+	RequireMessageNotSeen,
+	RequireKnownPayloadStatus,
+	RequireValidatorInPTC,
+	RequireBlockRootSeen,
+	RequireBlockRootValid,
+	RequireSignatureValid,
+}
+
+// GossipPayloadAttestationMessageRequirements is a requirement list for gossip payload attestation messages.
+var GossipPayloadAttestationMessageRequirements = RequirementList(PayloadAttGossipRequirements)
+
+var (
+	ErrIncorrectPayloadAttSlot      = errors.New("payload att slot does not match the current slot")
+	ErrIncorrectPayloadAttStatus    = errors.New("unknown payload att status")
+	ErrPayloadAttBlockRootNotSeen   = errors.New("block root not seen")
+	ErrPayloadAttBlockRootInvalid   = errors.New("block root invalid")
+	ErrIncorrectPayloadAttValidator = errors.New("validator not present in payload timeliness committee")
+	ErrInvalidPayloadAttMessage     = errors.New("invalid payload attestation message")
+)
+
+var _ PayloadAttestationMsgVerifier = &PayloadAttMsgVerifier{}
+
+// PayloadAttMsgVerifier is a read-only verifier for payload attestation messages.
+type PayloadAttMsgVerifier struct {
+	*sharedResources
+	results *results
+	pa      payloadattestation.ROMessage
+}
+
+// VerifyCurrentSlot verifies if the current slot matches the expected slot.
+// Represents the following spec verification:
+// [IGNORE] data.slot is the current slot.
+func (v *PayloadAttMsgVerifier) VerifyCurrentSlot() (err error) {
+	defer v.record(RequireCurrentSlot, &err)
+
+	if v.pa.Slot() != v.clock.CurrentSlot() {
+		log.WithFields(logFields(v.pa)).Errorf("does not match current slot %d", v.clock.CurrentSlot())
+		return ErrIncorrectPayloadAttSlot
+	}
+
+	return nil
+}
+
+// VerifyPayloadStatus verifies if the payload status is known.
+// In Gloas, payload status is represented by booleans, so there is no invalid enum to reject.
+func (v *PayloadAttMsgVerifier) VerifyPayloadStatus() (err error) {
+	defer v.record(RequireKnownPayloadStatus, &err)
+	return nil
+}
+
+// VerifyBlockRootSeen verifies if the block root has been seen before.
+// Represents the following spec verification:
+// [IGNORE] The attestation's data.beacon_block_root has been seen (via both gossip and non-gossip sources).
+func (v *PayloadAttMsgVerifier) VerifyBlockRootSeen(parentSeen func([32]byte) bool) (err error) {
+	defer v.record(RequireBlockRootSeen, &err)
+	if parentSeen != nil && parentSeen(v.pa.BeaconBlockRoot()) {
+		return nil
+	}
+	log.WithFields(logFields(v.pa)).Error(ErrPayloadAttBlockRootNotSeen.Error())
+	return ErrPayloadAttBlockRootNotSeen
+}
+
+// VerifyBlockRootValid verifies if the block root is valid.
+// Represents the following spec verification:
+// [REJECT] The beacon block with root data.beacon_block_root passes validation.
+func (v *PayloadAttMsgVerifier) VerifyBlockRootValid(badBlock func([32]byte) bool) (err error) {
+	defer v.record(RequireBlockRootValid, &err)
+
+	if badBlock != nil && badBlock(v.pa.BeaconBlockRoot()) {
+		log.WithFields(logFields(v.pa)).Error(ErrPayloadAttBlockRootInvalid.Error())
+		return ErrPayloadAttBlockRootInvalid
+	}
+
+	return nil
+}
+
+// VerifyValidatorInPTC verifies if the validator is present.
+// Represents the following spec verification:
+// [REJECT] The validator index is within the payload committee in get_ptc(state, data.slot). For the current's slot head state.
+func (v *PayloadAttMsgVerifier) VerifyValidatorInPTC(ctx context.Context, st state.BeaconState) (err error) {
+	defer v.record(RequireValidatorInPTC, &err)
+
+	ptc, err := gloas.PayloadTimelinessCommittee(ctx, st, v.pa.Slot())
+	if err != nil {
+		return err
+	}
+
+	idx := slices.Index(ptc, v.pa.ValidatorIndex())
+	if idx == -1 {
+		log.WithFields(logFields(v.pa)).Error(ErrIncorrectPayloadAttValidator.Error())
+		return ErrIncorrectPayloadAttValidator
+	}
+
+	return nil
+}
+
+// VerifySignature verifies the signature of the payload attestation message.
+// Represents the following spec verification:
+// [REJECT] The signature of payload_attestation_message.signature is valid with respect to the validator index.
+func (v *PayloadAttMsgVerifier) VerifySignature(st state.BeaconState) (err error) {
+	defer v.record(RequireSignatureValid, &err)
+
+	err = validatePayloadAttestationMessageSignature(st, v.pa)
+	if err != nil {
+		if errors.Is(err, signing.ErrSigFailedToVerify) {
+			log.WithFields(logFields(v.pa)).Error("Signature failed to validate")
+		} else {
+			log.WithFields(logFields(v.pa)).WithError(err).Error("Could not validate signature")
+		}
+		return err
+	}
+
+	return nil
+}
+
+// VerifiedPayloadAttestation returns a verified payload attestation message by checking all requirements.
+func (v *PayloadAttMsgVerifier) VerifiedPayloadAttestation() (payloadattestation.VerifiedROMessage, error) {
+	if v.results.allSatisfied() {
+		return payloadattestation.NewVerifiedROMessage(v.pa), nil
+	}
+	return payloadattestation.VerifiedROMessage{}, ErrInvalidPayloadAttMessage
+}
+
+// SatisfyRequirement allows the caller to manually mark a requirement as satisfied.
+func (v *PayloadAttMsgVerifier) SatisfyRequirement(req Requirement) {
+	v.record(req, nil)
+}
+
+// ValidatePayloadAttestationMessageSignature verifies the signature of a payload attestation message.
+func validatePayloadAttestationMessageSignature(st state.BeaconState, payloadAtt payloadattestation.ROMessage) error {
+	val, err := st.ValidatorAtIndex(payloadAtt.ValidatorIndex())
+	if err != nil {
+		return err
+	}
+
+	pub, err := bls.PublicKeyFromBytes(val.PublicKey)
+	if err != nil {
+		return err
+	}
+
+	s := payloadAtt.Signature()
+	sig, err := bls.SignatureFromBytes(s[:])
+	if err != nil {
+		return err
+	}
+
+	currentEpoch := slots.ToEpoch(st.Slot())
+	domain, err := signing.Domain(st.Fork(), currentEpoch, params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
+	if err != nil {
+		return err
+	}
+
+	root, err := payloadAtt.SigningRoot(domain)
+	if err != nil {
+		return err
+	}
+
+	if !sig.Verify(pub, root[:]) {
+		return signing.ErrSigFailedToVerify
+	}
+	return nil
+}
+
+// record records the result of a requirement verification.
+func (v *PayloadAttMsgVerifier) record(req Requirement, err *error) {
+	if err == nil || *err == nil {
+		v.results.record(req, nil)
+		return
+	}
+
+	v.results.record(req, *err)
+}
+
+// logFields returns log fields for a ROMessage instance.
+func logFields(payload payloadattestation.ROMessage) logrus.Fields {
+	return logrus.Fields{
+		"slot":              payload.Slot(),
+		"validatorIndex":    payload.ValidatorIndex(),
+		"signature":         fmt.Sprintf("%#x", payload.Signature()),
+		"beaconBlockRoot":   fmt.Sprintf("%#x", payload.BeaconBlockRoot()),
+		"payloadPresent":    payload.PayloadPresent(),
+		"blobDataAvailable": payload.BlobDataAvailable(),
+	}
+}

beacon-chain/verification/payload_attestation_mock.go

@@ -0,0 +1,51 @@
+package verification
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/epbs/payload-attestation"
+)
+
+type MockPayloadAttestation struct {
+	ErrIncorrectPayloadAttSlot      error
+	ErrIncorrectPayloadAttStatus    error
+	ErrIncorrectPayloadAttValidator error
+	ErrPayloadAttBlockRootNotSeen   error
+	ErrPayloadAttBlockRootInvalid   error
+	ErrInvalidPayloadAttMessage     error
+	ErrInvalidMessageSignature      error
+	ErrUnsatisfiedRequirement       error
+}
+
+var _ PayloadAttestationMsgVerifier = &MockPayloadAttestation{}
+
+func (m *MockPayloadAttestation) VerifyCurrentSlot() error {
+	return m.ErrIncorrectPayloadAttSlot
+}
+
+func (m *MockPayloadAttestation) VerifyPayloadStatus() error {
+	return m.ErrIncorrectPayloadAttStatus
+}
+
+func (m *MockPayloadAttestation) VerifyValidatorInPTC(ctx context.Context, st state.BeaconState) error {
+	return m.ErrIncorrectPayloadAttValidator
+}
+
+func (m *MockPayloadAttestation) VerifyBlockRootSeen(func([32]byte) bool) error {
+	return m.ErrPayloadAttBlockRootNotSeen
+}
+
+func (m *MockPayloadAttestation) VerifyBlockRootValid(func([32]byte) bool) error {
+	return m.ErrPayloadAttBlockRootInvalid
+}
+
+func (m *MockPayloadAttestation) VerifySignature(st state.BeaconState) (err error) {
+	return m.ErrInvalidMessageSignature
+}
+
+func (m *MockPayloadAttestation) VerifiedPayloadAttestation() (payloadattestation.VerifiedROMessage, error) {
+	return payloadattestation.VerifiedROMessage{}, nil
+}
+
+func (m *MockPayloadAttestation) SatisfyRequirement(req Requirement) {}

changelog/t_gloas-process-attestations.md

@@ -1,3 +0,0 @@
-### Added
-
-- Added process attestation for gloas

consensus-types/epbs/payload-attestation/BUILD.bazel

@@ -0,0 +1,15 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["readonly_message.go"],
+    importpath = "github.com/OffchainLabs/prysm/v7/consensus-types/epbs/payload-attestation",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/signing:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)

consensus-types/epbs/payload-attestation/readonly_message.go

@@ -0,0 +1,87 @@
+package payloadattestation
+
+import (
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/pkg/errors"
+)
+
+var (
+	errNilPayloadAttMessage   = errors.New("received nil payload attestation message")
+	errNilPayloadAttData      = errors.New("received nil payload attestation data")
+	errNilPayloadAttSignature = errors.New("received nil payload attestation signature")
+)
+
+// ROMessage represents a read-only payload attestation message.
+type ROMessage struct {
+	m *ethpb.PayloadAttestationMessage
+}
+
+// validatePayloadAtt checks if the given payload attestation message is valid.
+func validatePayloadAtt(m *ethpb.PayloadAttestationMessage) error {
+	if m == nil {
+		return errNilPayloadAttMessage
+	}
+	if m.Data == nil {
+		return errNilPayloadAttData
+	}
+	if len(m.Signature) == 0 {
+		return errNilPayloadAttSignature
+	}
+	return nil
+}
+
+// NewReadOnly creates a new ReadOnly instance after validating the message.
+func NewReadOnly(m *ethpb.PayloadAttestationMessage) (ROMessage, error) {
+	if err := validatePayloadAtt(m); err != nil {
+		return ROMessage{}, err
+	}
+	return ROMessage{m}, nil
+}
+
+// ValidatorIndex returns the validator index from the payload attestation message.
+func (r *ROMessage) ValidatorIndex() primitives.ValidatorIndex {
+	return r.m.ValidatorIndex
+}
+
+// Signature returns the signature from the payload attestation message.
+func (r *ROMessage) Signature() [96]byte {
+	return bytesutil.ToBytes96(r.m.Signature)
+}
+
+// BeaconBlockRoot returns the beacon block root from the payload attestation message.
+func (r *ROMessage) BeaconBlockRoot() [32]byte {
+	return bytesutil.ToBytes32(r.m.Data.BeaconBlockRoot)
+}
+
+// Slot returns the slot from the payload attestation message.
+func (r *ROMessage) Slot() primitives.Slot {
+	return r.m.Data.Slot
+}
+
+// PayloadPresent returns whether the payload was present.
+func (r *ROMessage) PayloadPresent() bool {
+	return r.m.Data.PayloadPresent
+}
+
+// BlobDataAvailable returns whether blob data was available.
+func (r *ROMessage) BlobDataAvailable() bool {
+	return r.m.Data.BlobDataAvailable
+}
+
+// SigningRoot returns the signing root from the payload attestation message.
+func (r *ROMessage) SigningRoot(domain []byte) ([32]byte, error) {
+	return signing.ComputeSigningRoot(r.m.Data, domain)
+}
+
+// VerifiedROMessage represents a verified read-only payload attestation message.
+type VerifiedROMessage struct {
+	ROMessage
+}
+
+// NewVerifiedROMessage creates a new VerifiedROMessage instance after validating the message.
+func NewVerifiedROMessage(r ROMessage) VerifiedROMessage {
+	return VerifiedROMessage{r}
+}

testing/spectest/mainnet/BUILD.bazel

@@ -201,7 +201,6 @@ go_test(
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
-        "gloas__operations__attestation_test.go",
         "gloas__operations__execution_payload_header_test.go",
         "gloas__operations__payload_attestation_test.go",
         "gloas__operations__proposer_slashing_test.go",

testing/spectest/mainnet/gloas__operations__attestation_test.go

@@ -1,11 +0,0 @@
-package mainnet
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
-)
-
-func TestMainnet_Gloas_Operations_Attestation(t *testing.T) {
-	operations.RunAttestationTest(t, "mainnet")
-}

testing/spectest/minimal/BUILD.bazel

@@ -207,7 +207,6 @@ go_test(
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
-        "gloas__operations__attestation_test.go",
         "gloas__operations__execution_payload_bid_test.go",
         "gloas__operations__payload_attestation_test.go",
         "gloas__operations__proposer_slashing_test.go",

testing/spectest/minimal/gloas__operations__attestation_test.go

@@ -1,11 +0,0 @@
-package minimal
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
-)
-
-func TestMinimal_Gloas_Operations_Attestation(t *testing.T) {
-	operations.RunAttestationTest(t, "minimal")
-}

testing/spectest/shared/gloas/operations/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     testonly = True,
     srcs = [
-        "attestation.go",
         "execution_payload_bid.go",
         "helpers.go",
         "payload_attestation.go",
@@ -13,7 +12,6 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations",
     visibility = ["//visibility:public"],
     deps = [
-        "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//consensus-types/blocks:go_default_library",

testing/spectest/shared/gloas/operations/attestation.go

@@ -1,26 +0,0 @@
-package operations
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/altair"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	common "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/common/operations"
-)
-
-func blockWithAttestation(attestationSSZ []byte) (interfaces.SignedBeaconBlock, error) {
-	att := &ethpb.AttestationElectra{}
-	if err := att.UnmarshalSSZ(attestationSSZ); err != nil {
-		return nil, err
-	}
-	b := &ethpb.BeaconBlockGloas{}
-	b.Body = &ethpb.BeaconBlockBodyGloas{Attestations: []*ethpb.AttestationElectra{att}}
-	return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockGloas{Block: b})
-}
-
-func RunAttestationTest(t *testing.T, config string) {
-	common.RunAttestationTest(t, config, version.String(version.Gloas), blockWithAttestation, altair.ProcessAttestationsNoVerifySignature, sszToState)
-}