Go fmt

api/server/structs/conversions_state.go

@@ -972,224 +972,3 @@ func BeaconStateFuluFromConsensus(st beaconState.BeaconState) (*BeaconStateFulu,
 		ProposerLookahead:             lookahead,
 	}, nil
 }
-
-// ----------------------------------------------------------------------------
-// Gloas
-// ----------------------------------------------------------------------------
-
-func BeaconStateGloasFromConsensus(st beaconState.BeaconState) (*BeaconStateGloas, error) {
-	srcBr := st.BlockRoots()
-	br := make([]string, len(srcBr))
-	for i, r := range srcBr {
-		br[i] = hexutil.Encode(r)
-	}
-	srcSr := st.StateRoots()
-	sr := make([]string, len(srcSr))
-	for i, r := range srcSr {
-		sr[i] = hexutil.Encode(r)
-	}
-	srcHr := st.HistoricalRoots()
-	hr := make([]string, len(srcHr))
-	for i, r := range srcHr {
-		hr[i] = hexutil.Encode(r)
-	}
-	srcVotes := st.Eth1DataVotes()
-	votes := make([]*Eth1Data, len(srcVotes))
-	for i, e := range srcVotes {
-		votes[i] = Eth1DataFromConsensus(e)
-	}
-	srcVals := st.Validators()
-	vals := make([]*Validator, len(srcVals))
-	for i, v := range srcVals {
-		vals[i] = ValidatorFromConsensus(v)
-	}
-	srcBals := st.Balances()
-	bals := make([]string, len(srcBals))
-	for i, b := range srcBals {
-		bals[i] = fmt.Sprintf("%d", b)
-	}
-	srcRm := st.RandaoMixes()
-	rm := make([]string, len(srcRm))
-	for i, m := range srcRm {
-		rm[i] = hexutil.Encode(m)
-	}
-	srcSlashings := st.Slashings()
-	slashings := make([]string, len(srcSlashings))
-	for i, s := range srcSlashings {
-		slashings[i] = fmt.Sprintf("%d", s)
-	}
-	srcPrevPart, err := st.PreviousEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	prevPart := make([]string, len(srcPrevPart))
-	for i, p := range srcPrevPart {
-		prevPart[i] = fmt.Sprintf("%d", p)
-	}
-	srcCurrPart, err := st.CurrentEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	currPart := make([]string, len(srcCurrPart))
-	for i, p := range srcCurrPart {
-		currPart[i] = fmt.Sprintf("%d", p)
-	}
-	srcIs, err := st.InactivityScores()
-	if err != nil {
-		return nil, err
-	}
-	is := make([]string, len(srcIs))
-	for i, s := range srcIs {
-		is[i] = fmt.Sprintf("%d", s)
-	}
-	currSc, err := st.CurrentSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	nextSc, err := st.NextSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	srcHs, err := st.HistoricalSummaries()
-	if err != nil {
-		return nil, err
-	}
-	hs := make([]*HistoricalSummary, len(srcHs))
-	for i, s := range srcHs {
-		hs[i] = HistoricalSummaryFromConsensus(s)
-	}
-	nwi, err := st.NextWithdrawalIndex()
-	if err != nil {
-		return nil, err
-	}
-	nwvi, err := st.NextWithdrawalValidatorIndex()
-	if err != nil {
-		return nil, err
-	}
-	drsi, err := st.DepositRequestsStartIndex()
-	if err != nil {
-		return nil, err
-	}
-	dbtc, err := st.DepositBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	ebtc, err := st.ExitBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	eee, err := st.EarliestExitEpoch()
-	if err != nil {
-		return nil, err
-	}
-	cbtc, err := st.ConsolidationBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	ece, err := st.EarliestConsolidationEpoch()
-	if err != nil {
-		return nil, err
-	}
-	pbd, err := st.PendingDeposits()
-	if err != nil {
-		return nil, err
-	}
-	ppw, err := st.PendingPartialWithdrawals()
-	if err != nil {
-		return nil, err
-	}
-	pc, err := st.PendingConsolidations()
-	if err != nil {
-		return nil, err
-	}
-	srcLookahead, err := st.ProposerLookahead()
-	if err != nil {
-		return nil, err
-	}
-	lookahead := make([]string, len(srcLookahead))
-	for i, v := range srcLookahead {
-		lookahead[i] = fmt.Sprintf("%d", uint64(v))
-	}
-
-	////////// TODO new ones
-	lepb, err := st.LatestExecutionPayloadBid()
-	if err != nil {
-		return nil, err
-	}
-	builders, err := st.Builders()
-	if err != nil {
-		return nil, err
-	}
-	nwbi, err := st.NextWithdrawalBuilderIndex()
-	if err != nil {
-		return nil, err
-	}
-	epa, err := st.ExecutionPayloadAvailability()
-	if err != nil {
-		return nil, err
-	}
-	bpp, err := st.BuilderPendingPayments()
-	if err != nil {
-		return nil, err
-	}
-	bpw, err := st.BuilderPendingWithdrawals()
-	if err != nil {
-		return nil, err
-	}
-	lbh, err := st.LatestBlockHash()
-	if err != nil {
-		return nil, err
-	}
-	pew, err := st.PayloadExpectedWithdrawals()
-	if err != nil {
-		return nil, err
-	}
-
-	return &BeaconStateGloas{
-		GenesisTime:                   fmt.Sprintf("%d", st.GenesisTime().Unix()),
-		GenesisValidatorsRoot:         hexutil.Encode(st.GenesisValidatorsRoot()),
-		Slot:                          fmt.Sprintf("%d", st.Slot()),
-		Fork:                          ForkFromConsensus(st.Fork()),
-		LatestBlockHeader:             BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
-		BlockRoots:                    br,
-		StateRoots:                    sr,
-		HistoricalRoots:               hr,
-		Eth1Data:                      Eth1DataFromConsensus(st.Eth1Data()),
-		Eth1DataVotes:                 votes,
-		Eth1DepositIndex:              fmt.Sprintf("%d", st.Eth1DepositIndex()),
-		Validators:                    vals,
-		Balances:                      bals,
-		RandaoMixes:                   rm,
-		Slashings:                     slashings,
-		PreviousEpochParticipation:    prevPart,
-		CurrentEpochParticipation:     currPart,
-		JustificationBits:             hexutil.Encode(st.JustificationBits()),
-		PreviousJustifiedCheckpoint:   CheckpointFromConsensus(st.PreviousJustifiedCheckpoint()),
-		CurrentJustifiedCheckpoint:    CheckpointFromConsensus(st.CurrentJustifiedCheckpoint()),
-		FinalizedCheckpoint:           CheckpointFromConsensus(st.FinalizedCheckpoint()),
-		InactivityScores:              is,
-		CurrentSyncCommittee:          SyncCommitteeFromConsensus(currSc),
-		NextSyncCommittee:             SyncCommitteeFromConsensus(nextSc),
-		NextWithdrawalIndex:           fmt.Sprintf("%d", nwi),
-		NextWithdrawalValidatorIndex:  fmt.Sprintf("%d", nwvi),
-		HistoricalSummaries:           hs,
-		DepositRequestsStartIndex:     fmt.Sprintf("%d", drsi),
-		DepositBalanceToConsume:       fmt.Sprintf("%d", dbtc),
-		ExitBalanceToConsume:          fmt.Sprintf("%d", ebtc),
-		EarliestExitEpoch:             fmt.Sprintf("%d", eee),
-		ConsolidationBalanceToConsume: fmt.Sprintf("%d", cbtc),
-		EarliestConsolidationEpoch:    fmt.Sprintf("%d", ece),
-		PendingDeposits:               PendingDepositsFromConsensus(pbd),
-		PendingPartialWithdrawals:     PendingPartialWithdrawalsFromConsensus(ppw),
-		PendingConsolidations:         PendingConsolidationsFromConsensus(pc),
-		ProposerLookahead:             lookahead,
-		LatestExecutionPayloadBid:     LatestExecutionPayloadBidFromConsensus(lepb),
-		Builders:                      BuildersFromConsensus(builders),
-		NextWithdrawalBuilderIndex:    fmt.Sprintf("%d", nwbi),
-		ExecutionPayloadAvailability:  epa,
-		BuilderPendingPayments:        BuilderPendingPaymentsFromConsensus(bpp),
-		BuilderPendingWithdrawals:     BuilderPendingWithdrawalsFromConsensus(bpw),
-		LatestBlockHash:               hexutil.Encode(lbh[:]),
-		PayloadExpectedWithdrawals:    PayloadExpectedWithdrawalsFromConsensus(pew),
-	}, nil
-}

api/server/structs/other.go

@@ -262,37 +262,3 @@ type PendingConsolidation struct {
 	SourceIndex string `json:"source_index"`
 	TargetIndex string `json:"target_index"`
 }
-
-type ExecutionPayloadBid struct {
-	ParentBlockHash        string `json:"parent_block_hash"`
-	ParentBlockRoot        string `json:"parent_block_root"`
-	BlockHash              string `json:"block_hash"`
-	PrevRandao             string `json:"prev_rando"`
-	FeeRecipient           string `json:"fee_recipient"`
-	GasLimit               string `json:"gas_limit"`
-	BuilderIndex           string `json:"builder_index"`
-	Slot                   string `json:"slot"`
-	Value                  string `json:"value"`
-	ExecutionPayment       string `json:"execution_payment"`
-	BlobKZGCommitmentsRoot string `json:"blob_kzg_commitments_root"`
-}
-
-type Builder struct {
-	Pubkey            string `json:"pubkey"`
-	Version           string `json:"version"`
-	ExecutionAddress  string `json:"execution_address"`
-	Balance           string `json:"balance"`
-	DepositEpoch      string `json:"deposit_epoch"`
-	WithdrawableEpoch string `json:"withdrawable_epoch"`
-}
-
-type BuilderPendingPayment struct {
-	Weight     string                    `json:"weight"`
-	Withdrawal *BuilderPendingWithdrawal `json:"withdrawal"`
-}
-
-type BuilderPendingWithdrawal struct {
-	FeeRecipient string `json:"fee_recipient"`
-	Amount       string `json:"amount"`
-	BuilderIndex string `json:"builder_index"`
-}

api/server/structs/state.go

@@ -221,51 +221,3 @@ type BeaconStateFulu struct {
 	PendingConsolidations         []*PendingConsolidation      `json:"pending_consolidations"`
 	ProposerLookahead             []string                     `json:"proposer_lookahead"`
 }
-
-type BeaconStateGloas struct {
-	GenesisTime                   string                      `json:"genesis_time"`
-	GenesisValidatorsRoot         string                      `json:"genesis_validators_root"`
-	Slot                          string                      `json:"slot"`
-	Fork                          *Fork                       `json:"fork"`
-	LatestBlockHeader             *BeaconBlockHeader          `json:"latest_block_header"`
-	BlockRoots                    []string                    `json:"block_roots"`
-	StateRoots                    []string                    `json:"state_roots"`
-	HistoricalRoots               []string                    `json:"historical_roots"`
-	Eth1Data                      *Eth1Data                   `json:"eth1_data"`
-	Eth1DataVotes                 []*Eth1Data                 `json:"eth1_data_votes"`
-	Eth1DepositIndex              string                      `json:"eth1_deposit_index"`
-	Validators                    []*Validator                `json:"validators"`
-	Balances                      []string                    `json:"balances"`
-	RandaoMixes                   []string                    `json:"randao_mixes"`
-	Slashings                     []string                    `json:"slashings"`
-	PreviousEpochParticipation    []string                    `json:"previous_epoch_participation"`
-	CurrentEpochParticipation     []string                    `json:"current_epoch_participation"`
-	JustificationBits             string                      `json:"justification_bits"`
-	PreviousJustifiedCheckpoint   *Checkpoint                 `json:"previous_justified_checkpoint"`
-	CurrentJustifiedCheckpoint    *Checkpoint                 `json:"current_justified_checkpoint"`
-	FinalizedCheckpoint           *Checkpoint                 `json:"finalized_checkpoint"`
-	InactivityScores              []string                    `json:"inactivity_scores"`
-	CurrentSyncCommittee          *SyncCommittee              `json:"current_sync_committee"`
-	NextSyncCommittee             *SyncCommittee              `json:"next_sync_committee"`
-	NextWithdrawalIndex           string                      `json:"next_withdrawal_index"`
-	NextWithdrawalValidatorIndex  string                      `json:"next_withdrawal_validator_index"`
-	HistoricalSummaries           []*HistoricalSummary        `json:"historical_summaries"`
-	DepositRequestsStartIndex     string                      `json:"deposit_requests_start_index"`
-	DepositBalanceToConsume       string                      `json:"deposit_balance_to_consume"`
-	ExitBalanceToConsume          string                      `json:"exit_balance_to_consume"`
-	EarliestExitEpoch             string                      `json:"earliest_exit_epoch"`
-	ConsolidationBalanceToConsume string                      `json:"consolidation_balance_to_consume"`
-	EarliestConsolidationEpoch    string                      `json:"earliest_consolidation_epoch"`
-	PendingDeposits               []*PendingDeposit           `json:"pending_deposits"`
-	PendingPartialWithdrawals     []*PendingPartialWithdrawal `json:"pending_partial_withdrawals"`
-	PendingConsolidations         []*PendingConsolidation     `json:"pending_consolidations"`
-	ProposerLookahead             []string                    `json:"proposer_lookahead"`
-	LatestExecutionPayloadBid     *ExecutionPayloadBid        `json:"latest_execution_payload_bid"`
-	Builders                      []*Builder                  `json:"builders"`
-	NextWithdrawalBuilderIndex    string                      `json:"next_withdrawal_builder_index"`
-	ExecutionPayloadAvailability  string                      `json:"execution_payload_availability"`
-	BuilderPendingPayments        []*BuilderPendingPayment    `json:"builder_pending_payments"`
-	BuilderPendingWithdrawals     []*BuilderPendingWithdrawal `json:"builder_pending_withdrawals"`
-	LatestBlockHash               string                      `json:"latest_block_hash"`
-	PayloadExpectedWithdrawals    []*Withdrawal               `json:"payload_expected_withdrawals"`
-}

beacon-chain/core/gloas/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "bid.go",
+        "payload_attestation.go",
         "pending_payment.go",
         "proposer_slashing.go",
     ],
@@ -14,12 +15,16 @@ go_library(
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/bls/common:go_default_library",
+        "//crypto/hash:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
@@ -30,6 +35,7 @@ go_test(
     name = "go_default_test",
     srcs = [
         "bid_test.go",
+        "payload_attestation_test.go",
         "pending_payment_test.go",
         "proposer_slashing_test.go",
     ],
@@ -40,6 +46,7 @@ go_test(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
@@ -50,8 +57,10 @@ go_test(
         "//proto/prysm/v1alpha1/validator-client:go_default_library",
         "//runtime/version:go_default_library",
         "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
+        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

beacon-chain/core/gloas/payload_attestation.go

@@ -0,0 +1,253 @@
+package gloas
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"fmt"
+	"slices"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls"
+	"github.com/OffchainLabs/prysm/v7/crypto/hash"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+	"github.com/pkg/errors"
+)
+
+// ProcessPayloadAttestations validates payload attestations in a block body.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// process_payload_attestation(state: BeaconState, payload_attestation: PayloadAttestation):
+//
+//	data = payload_attestation.data
+//	assert data.beacon_block_root == state.latest_block_header.parent_root
+//	assert data.slot + 1 == state.slot
+//	indexed = get_indexed_payload_attestation(state, data.slot, payload_attestation)
+//	assert is_valid_indexed_payload_attestation(state, indexed)
+func ProcessPayloadAttestations(ctx context.Context, st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) error {
+	atts, err := body.PayloadAttestations()
+	if err != nil {
+		return errors.Wrap(err, "failed to get payload attestations from block body")
+	}
+	if len(atts) == 0 {
+		return nil
+	}
+
+	header := st.LatestBlockHeader()
+
+	for i, att := range atts {
+		data := att.Data
+		if !bytes.Equal(data.BeaconBlockRoot, header.ParentRoot) {
+			return fmt.Errorf("payload attestation %d has wrong parent: got %x want %x", i, data.BeaconBlockRoot, header.ParentRoot)
+		}
+
+		dataSlot, err := data.Slot.SafeAdd(1)
+		if err != nil {
+			return errors.Wrapf(err, "payload attestation %d has invalid slot addition", i)
+		}
+		if dataSlot != st.Slot() {
+			return fmt.Errorf("payload attestation %d has wrong slot: got %d want %d", i, data.Slot+1, st.Slot())
+		}
+
+		indexed, err := indexedPayloadAttestation(ctx, st, att)
+		if err != nil {
+			return errors.Wrapf(err, "payload attestation %d failed to convert to indexed form", i)
+		}
+		if err := validIndexedPayloadAttestation(st, indexed); err != nil {
+			return errors.Wrapf(err, "payload attestation %d failed to verify indexed form", i)
+		}
+	}
+	return nil
+}
+
+// indexedPayloadAttestation converts a payload attestation into its indexed form.
+func indexedPayloadAttestation(ctx context.Context, st state.ReadOnlyBeaconState, att *eth.PayloadAttestation) (*consensus_types.IndexedPayloadAttestation, error) {
+	committee, err := payloadCommittee(ctx, st, att.Data.Slot)
+	if err != nil {
+		return nil, err
+	}
+	indices := make([]primitives.ValidatorIndex, 0, len(committee))
+	for i, idx := range committee {
+		if att.AggregationBits.BitAt(uint64(i)) {
+			indices = append(indices, idx)
+		}
+	}
+	slices.Sort(indices)
+
+	return &consensus_types.IndexedPayloadAttestation{
+		AttestingIndices: indices,
+		Data:             att.Data,
+		Signature:        att.Signature,
+	}, nil
+}
+
+// payloadCommittee returns the payload timeliness committee for a given slot for the state.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// get_ptc(state: BeaconState, slot: Slot) -> Vector[ValidatorIndex, PTC_SIZE]:
+//
+//	epoch = compute_epoch_at_slot(slot)
+//	seed = hash(get_seed(state, epoch, DOMAIN_PTC_ATTESTER) + uint_to_bytes(slot))
+//	indices = []
+//	committees_per_slot = get_committee_count_per_slot(state, epoch)
+//	for i in range(committees_per_slot):
+//	  committee = get_beacon_committee(state, slot, CommitteeIndex(i))
+//	  indices.extend(committee)
+//	return compute_balance_weighted_selection(state, indices, seed, size=PTC_SIZE, shuffle_indices=False)
+func payloadCommittee(ctx context.Context, st state.ReadOnlyBeaconState, slot primitives.Slot) ([]primitives.ValidatorIndex, error) {
+	epoch := slots.ToEpoch(slot)
+	seed, err := ptcSeed(st, epoch, slot)
+	if err != nil {
+		return nil, err
+	}
+
+	activeCount, err := helpers.ActiveValidatorCount(ctx, st, epoch)
+	if err != nil {
+		return nil, err
+	}
+
+	committeesPerSlot := helpers.SlotCommitteeCount(activeCount)
+	out := make([]primitives.ValidatorIndex, 0, activeCount/uint64(params.BeaconConfig().SlotsPerEpoch))
+
+	for i := primitives.CommitteeIndex(0); i < primitives.CommitteeIndex(committeesPerSlot); i++ {
+		committee, err := helpers.BeaconCommitteeFromState(ctx, st, slot, i)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to get beacon committee %d", i)
+		}
+		out = append(out, committee...)
+	}
+
+	return selectByBalance(ctx, st, out, seed, fieldparams.PTCSize)
+}
+
+// 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)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	return hash.Hash(append(seed[:], bytesutil.Bytes8(uint64(slot))...)), nil
+}
+
+// selectByBalance selects a balance-weighted subset of input candidates.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// compute_balance_weighted_selection(state, indices, seed, size, shuffle_indices):
+// Note: shuffle_indices is false for PTC.
+//
+//	total = len(indices); selected = []; i = 0
+//	while len(selected) < size:
+//	  next = i % total
+//	  if shuffle_indices: next = compute_shuffled_index(next, total, seed)
+//	  if compute_balance_weighted_acceptance(state, indices[next], seed, i):
+//	    selected.append(indices[next])
+//	  i += 1
+func selectByBalance(ctx context.Context, st state.ReadOnlyBeaconState, candidates []primitives.ValidatorIndex, seed [32]byte, count uint64) ([]primitives.ValidatorIndex, error) {
+	if len(candidates) == 0 {
+		return nil, errors.New("no candidates for balance weighted selection")
+	}
+
+	hashFunc := hash.CustomSHA256Hasher()
+	// Pre-allocate buffer for hash input: seed (32 bytes) + round counter (8 bytes).
+	var buf [40]byte
+	copy(buf[:], seed[:])
+	maxBalance := params.BeaconConfig().MaxEffectiveBalanceElectra
+
+	selected := make([]primitives.ValidatorIndex, 0, count)
+	total := uint64(len(candidates))
+	for i := uint64(0); uint64(len(selected)) < count; i++ {
+		if ctx.Err() != nil {
+			return nil, ctx.Err()
+		}
+		idx := candidates[i%total]
+		ok, err := acceptByBalance(st, idx, buf[:], hashFunc, maxBalance, i)
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			selected = append(selected, idx)
+		}
+	}
+	return selected, nil
+}
+
+// acceptByBalance determines if a validator is accepted based on its effective balance.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// compute_balance_weighted_acceptance(state, index, seed, i):
+//
+//	MAX_RANDOM_VALUE = 2**16 - 1
+//	random_bytes = hash(seed + uint_to_bytes(i // 16))
+//	offset = i % 16 * 2
+//	random_value = bytes_to_uint64(random_bytes[offset:offset+2])
+//	effective_balance = state.validators[index].effective_balance
+//	return effective_balance * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_value
+func acceptByBalance(st state.ReadOnlyBeaconState, idx primitives.ValidatorIndex, seedBuf []byte, hashFunc func([]byte) [32]byte, maxBalance uint64, round uint64) (bool, error) {
+	// Reuse the seed buffer by overwriting the last 8 bytes with the round counter.
+	binary.LittleEndian.PutUint64(seedBuf[len(seedBuf)-8:], round/16)
+	random := hashFunc(seedBuf)
+	offset := (round % 16) * 2
+	randomValue := uint64(binary.LittleEndian.Uint16(random[offset : offset+2])) // 16-bit draw per spec
+
+	val, err := st.ValidatorAtIndex(idx)
+	if err != nil {
+		return false, errors.Wrapf(err, "validator %d", idx)
+	}
+
+	return val.EffectiveBalance*fieldparams.MaxRandomValueElectra >= maxBalance*randomValue, nil
+}
+
+// validIndexedPayloadAttestation verifies the signature of an indexed payload attestation.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// is_valid_indexed_payload_attestation(state: BeaconState, indexed_payload_attestation: IndexedPayloadAttestation) -> bool:
+//
+//	indices = indexed_payload_attestation.attesting_indices
+//	return len(indices) > 0 and indices == sorted(indices) and
+//	  bls.FastAggregateVerify(
+//	    [state.validators[i].pubkey for i in indices],
+//	    compute_signing_root(indexed_payload_attestation.data, get_domain(state, DOMAIN_PTC_ATTESTER, compute_epoch_at_slot(attestation.data.slot)),
+//	    indexed_payload_attestation.signature,
+//	  )
+func validIndexedPayloadAttestation(st state.ReadOnlyBeaconState, att *consensus_types.IndexedPayloadAttestation) error {
+	indices := att.AttestingIndices
+	if len(indices) == 0 || !slices.IsSorted(indices) {
+		return errors.New("attesting indices empty or unsorted")
+	}
+
+	pubkeys := make([]bls.PublicKey, len(indices))
+	for i, idx := range indices {
+		val, err := st.ValidatorAtIndexReadOnly(idx)
+		if err != nil {
+			return errors.Wrapf(err, "validator %d", idx)
+		}
+		keyBytes := val.PublicKey()
+		key, err := bls.PublicKeyFromBytes(keyBytes[:])
+		if err != nil {
+			return errors.Wrapf(err, "pubkey %d", idx)
+		}
+		pubkeys[i] = key
+	}
+
+	domain, err := signing.Domain(st.Fork(), slots.ToEpoch(att.Data.Slot), params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
+	if err != nil {
+		return err
+	}
+	root, err := signing.ComputeSigningRoot(att.Data, domain)
+	if err != nil {
+		return err
+	}
+	sig, err := bls.SignatureFromBytes(att.Signature)
+	if err != nil {
+		return err
+	}
+
+	if !sig.FastAggregateVerify(pubkeys, root) {
+		return errors.New("invalid signature")
+	}
+	return nil
+}

beacon-chain/core/gloas/payload_attestation_test.go

@@ -0,0 +1,305 @@
+package gloas_test
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/OffchainLabs/go-bitfield"
+	"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/signing"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	testutil "github.com/OffchainLabs/prysm/v7/testing/util"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+)
+
+func TestProcessPayloadAttestations_WrongParent(t *testing.T) {
+	setupTestConfig(t)
+
+	_, pk := newKey(t)
+	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
+	require.NoError(t, st.SetSlot(2))
+	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
+	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
+
+	att := &eth.PayloadAttestation{
+		Data: &eth.PayloadAttestationData{
+			BeaconBlockRoot: bytes.Repeat([]byte{0xbb}, 32),
+			Slot:            1,
+		},
+		AggregationBits: bitfield.NewBitvector512(),
+		Signature:       make([]byte, 96),
+	}
+	body := buildBody(t, att)
+
+	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
+	require.ErrorContains(t, "wrong parent", err)
+}
+
+func TestProcessPayloadAttestations_WrongSlot(t *testing.T) {
+	setupTestConfig(t)
+
+	_, pk := newKey(t)
+	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
+	require.NoError(t, st.SetSlot(3))
+	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
+	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
+
+	att := &eth.PayloadAttestation{
+		Data: &eth.PayloadAttestationData{
+			BeaconBlockRoot: parentRoot,
+			Slot:            1,
+		},
+		AggregationBits: bitfield.NewBitvector512(),
+		Signature:       make([]byte, 96),
+	}
+	body := buildBody(t, att)
+
+	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
+	require.ErrorContains(t, "wrong slot", err)
+}
+
+func TestProcessPayloadAttestations_InvalidSignature(t *testing.T) {
+	setupTestConfig(t)
+
+	_, pk1 := newKey(t)
+	sk2, pk2 := newKey(t)
+	vals := []*eth.Validator{activeValidator(pk1), activeValidator(pk2)}
+	st := newTestState(t, vals, 2)
+	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
+	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
+
+	attData := &eth.PayloadAttestationData{
+		BeaconBlockRoot: parentRoot,
+		Slot:            1,
+	}
+	att := &eth.PayloadAttestation{
+		Data:            attData,
+		AggregationBits: setBits(bitfield.NewBitvector512(), 0),
+		Signature:       signAttestation(t, st, attData, []common.SecretKey{sk2}),
+	}
+	body := buildBody(t, att)
+
+	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
+	require.ErrorContains(t, "failed to verify indexed form", err)
+	require.ErrorContains(t, "invalid signature", err)
+}
+
+func TestProcessPayloadAttestations_EmptyAggregationBits(t *testing.T) {
+	setupTestConfig(t)
+
+	_, pk := newKey(t)
+	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
+	require.NoError(t, st.SetSlot(2))
+	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
+	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
+
+	attData := &eth.PayloadAttestationData{
+		BeaconBlockRoot: parentRoot,
+		Slot:            1,
+	}
+	att := &eth.PayloadAttestation{
+		Data:            attData,
+		AggregationBits: bitfield.NewBitvector512(),
+		Signature:       make([]byte, 96),
+	}
+	body := buildBody(t, att)
+
+	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
+	require.ErrorContains(t, "failed to verify indexed form", err)
+	require.ErrorContains(t, "attesting indices empty or unsorted", err)
+}
+
+func TestProcessPayloadAttestations_HappyPath(t *testing.T) {
+	helpers.ClearCache()
+	setupTestConfig(t)
+
+	sk1, pk1 := newKey(t)
+	sk2, pk2 := newKey(t)
+	vals := []*eth.Validator{activeValidator(pk1), activeValidator(pk2)}
+
+	st := newTestState(t, vals, 2)
+	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
+	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
+
+	attData := &eth.PayloadAttestationData{
+		BeaconBlockRoot: parentRoot,
+		Slot:            1,
+	}
+	aggBits := bitfield.NewBitvector512()
+	aggBits.SetBitAt(0, true)
+	aggBits.SetBitAt(1, true)
+
+	att := &eth.PayloadAttestation{
+		Data:            attData,
+		AggregationBits: aggBits,
+		Signature:       signAttestation(t, st, attData, []common.SecretKey{sk1, sk2}),
+	}
+	body := buildBody(t, att)
+
+	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
+	require.NoError(t, err)
+}
+
+func TestProcessPayloadAttestations_MultipleAttestations(t *testing.T) {
+	helpers.ClearCache()
+	setupTestConfig(t)
+
+	sk1, pk1 := newKey(t)
+	sk2, pk2 := newKey(t)
+	vals := []*eth.Validator{activeValidator(pk1), activeValidator(pk2)}
+
+	st := newTestState(t, vals, 2)
+	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
+	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
+
+	attData1 := &eth.PayloadAttestationData{
+		BeaconBlockRoot: parentRoot,
+		Slot:            1,
+	}
+	attData2 := &eth.PayloadAttestationData{
+		BeaconBlockRoot: parentRoot,
+		Slot:            1,
+	}
+
+	att1 := &eth.PayloadAttestation{
+		Data:            attData1,
+		AggregationBits: setBits(bitfield.NewBitvector512(), 0),
+		Signature:       signAttestation(t, st, attData1, []common.SecretKey{sk1}),
+	}
+	att2 := &eth.PayloadAttestation{
+		Data:            attData2,
+		AggregationBits: setBits(bitfield.NewBitvector512(), 1),
+		Signature:       signAttestation(t, st, attData2, []common.SecretKey{sk2}),
+	}
+
+	body := buildBody(t, att1, att2)
+
+	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
+	require.NoError(t, err)
+}
+
+func TestProcessPayloadAttestations_IndexedVerificationError(t *testing.T) {
+	setupTestConfig(t)
+
+	_, pk := newKey(t)
+	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
+	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
+	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
+
+	attData := &eth.PayloadAttestationData{
+		BeaconBlockRoot: parentRoot,
+		Slot:            0,
+	}
+	att := &eth.PayloadAttestation{
+		Data:            attData,
+		AggregationBits: setBits(bitfield.NewBitvector512(), 0),
+		Signature:       make([]byte, 96),
+	}
+	body := buildBody(t, att)
+
+	errState := &validatorLookupErrState{
+		BeaconState: st,
+		errIndex:    0,
+	}
+	err := gloas.ProcessPayloadAttestations(t.Context(), errState, body)
+	require.ErrorContains(t, "failed to verify indexed form", err)
+	require.ErrorContains(t, "validator 0", err)
+}
+
+func newTestState(t *testing.T, vals []*eth.Validator, slot primitives.Slot) state.BeaconState {
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
+	for _, v := range vals {
+		require.NoError(t, st.AppendValidator(v))
+		require.NoError(t, st.AppendBalance(v.EffectiveBalance))
+	}
+	require.NoError(t, st.SetSlot(slot))
+	require.NoError(t, helpers.UpdateCommitteeCache(t.Context(), st, slots.ToEpoch(slot)))
+	return st
+}
+
+func setupTestConfig(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.SlotsPerEpoch = 1
+	cfg.MaxEffectiveBalanceElectra = cfg.MaxEffectiveBalance
+	params.OverrideBeaconConfig(cfg)
+}
+
+func buildBody(t *testing.T, atts ...*eth.PayloadAttestation) interfaces.ReadOnlyBeaconBlockBody {
+	body := &eth.BeaconBlockBodyGloas{
+		PayloadAttestations:   atts,
+		RandaoReveal:          make([]byte, 96),
+		Eth1Data:              &eth.Eth1Data{},
+		Graffiti:              make([]byte, 32),
+		ProposerSlashings:     []*eth.ProposerSlashing{},
+		AttesterSlashings:     []*eth.AttesterSlashingElectra{},
+		Attestations:          []*eth.AttestationElectra{},
+		Deposits:              []*eth.Deposit{},
+		VoluntaryExits:        []*eth.SignedVoluntaryExit{},
+		SyncAggregate:         &eth.SyncAggregate{},
+		BlsToExecutionChanges: []*eth.SignedBLSToExecutionChange{},
+	}
+	wrapped, err := blocks.NewBeaconBlockBody(body)
+	require.NoError(t, err)
+	return wrapped
+}
+
+func setBits(bits bitfield.Bitvector512, idx uint64) bitfield.Bitvector512 {
+	bits.SetBitAt(idx, true)
+	return bits
+}
+
+func activeValidator(pub []byte) *eth.Validator {
+	return &eth.Validator{
+		PublicKey:                  pub,
+		EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
+		WithdrawalCredentials:      make([]byte, 32),
+		ActivationEligibilityEpoch: 0,
+		ActivationEpoch:            0,
+		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
+		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
+	}
+}
+
+func newKey(t *testing.T) (common.SecretKey, []byte) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	return sk, sk.PublicKey().Marshal()
+}
+
+func signAttestation(t *testing.T, st state.ReadOnlyBeaconState, data *eth.PayloadAttestationData, sks []common.SecretKey) []byte {
+	domain, err := signing.Domain(st.Fork(), slots.ToEpoch(data.Slot), params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
+	require.NoError(t, err)
+	root, err := signing.ComputeSigningRoot(data, domain)
+	require.NoError(t, err)
+
+	sigs := make([]common.Signature, len(sks))
+	for i, sk := range sks {
+		sigs[i] = sk.Sign(root[:])
+	}
+	agg := bls.AggregateSignatures(sigs)
+	return agg.Marshal()
+}
+
+type validatorLookupErrState struct {
+	state.BeaconState
+	errIndex primitives.ValidatorIndex
+}
+
+// ValidatorAtIndexReadOnly is overridden to simulate a missing validator lookup.
+func (s *validatorLookupErrState) ValidatorAtIndexReadOnly(idx primitives.ValidatorIndex) (state.ReadOnlyValidator, error) {
+	if idx == s.errIndex {
+		return nil, state.ErrNilValidatorsInState
+	}
+	return s.BeaconState.ValidatorAtIndexReadOnly(idx)
+}

beacon-chain/rpc/eth/config/handlers_test.go

@@ -197,6 +197,9 @@ func TestGetSpec(t *testing.T) {
 	var dbb [4]byte
 	copy(dbb[:], []byte{'0', '0', '0', '8'})
 	config.DomainBeaconBuilder = dbb
+	var dptc [4]byte
+	copy(dptc[:], []byte{'0', '0', '0', '8'})
+	config.DomainPTCAttester = dptc
 	var dam [4]byte
 	copy(dam[:], []byte{'1', '0', '0', '0'})
 	config.DomainApplicationMask = dam
@@ -212,7 +215,7 @@ func TestGetSpec(t *testing.T) {
 	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), &resp))
 	data, ok := resp.Data.(map[string]any)
 	require.Equal(t, true, ok)
-	assert.Equal(t, 186, len(data))
+	assert.Equal(t, 187, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -414,6 +417,8 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "0x30303036", v)
 			case "DOMAIN_AGGREGATE_AND_PROOF":
 				assert.Equal(t, "0x30303037", v)
+			case "DOMAIN_PTC_ATTESTER":
+				assert.Equal(t, "0x30303038", v)
 			case "DOMAIN_APPLICATION_MASK":
 				assert.Equal(t, "0x31303030", v)
 			case "DOMAIN_SYNC_COMMITTEE":

changelog/bastin_gloas-new-state-test.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- Add `NewBeaconStateGloas()`.

changelog/ttsao_add-gloas-process-payload-att.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add Gloas process payload attestation

config/fieldparams/mainnet.go

@@ -50,4 +50,7 @@ const (
 	// Introduced in Fulu network upgrade.
 	NumberOfColumns = 128 // NumberOfColumns refers to the specified number of data columns that can exist in a network.
 	CellsPerBlob    = 64  // CellsPerBlob refers to the number of cells in a (non-extended) blob.
+
+	// Introduced in Gloas network upgrade.
+	PTCSize = 512 // PTCSize is the size of the payload timeliness committee.
 )

config/fieldparams/minimal.go

@@ -50,4 +50,7 @@ const (
 	// Introduced in Fulu network upgrade.
 	NumberOfColumns = 128 // NumberOfColumns refers to the specified number of data columns that can exist in a network.
 	CellsPerBlob    = 64  // CellsPerBlob refers to the number of cells in a (non-extended) blob.
+
+	// Introduced in Gloas network upgrade.
+	PTCSize = 2 // PTCSize is the size of the payload timeliness committee.
 )

config/params/config.go

@@ -142,6 +142,7 @@ type BeaconChainConfig struct {
 	DomainApplicationBuilder          [4]byte `yaml:"DOMAIN_APPLICATION_BUILDER" spec:"true"`            // DomainApplicationBuilder defines the BLS signature domain for application builder.
 	DomainBLSToExecutionChange        [4]byte `yaml:"DOMAIN_BLS_TO_EXECUTION_CHANGE" spec:"true"`        // DomainBLSToExecutionChange defines the BLS signature domain to change withdrawal addresses to ETH1 prefix
 	DomainBeaconBuilder               [4]byte `yaml:"DOMAIN_BEACON_BUILDER" spec:"true"`                 // DomainBeaconBuilder defines the BLS signature domain for beacon block builder.
+	DomainPTCAttester                 [4]byte `yaml:"DOMAIN_PTC_ATTESTER" spec:"true"`                   // DomainPTCAttester defines the BLS signature domain for payload transaction committee attester.
 
 	// Prysm constants.
 	GenesisValidatorsRoot          [32]byte        // GenesisValidatorsRoot is the root hash of the genesis validators.

config/params/mainnet_config.go

@@ -185,6 +185,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	DomainApplicationBuilder:          bytesutil.Uint32ToBytes4(0x00000001),
 	DomainBLSToExecutionChange:        bytesutil.Uint32ToBytes4(0x0A000000),
 	DomainBeaconBuilder:               bytesutil.Uint32ToBytes4(0x0B000000),
+	DomainPTCAttester:                 bytesutil.Uint32ToBytes4(0x0C000000),
 
 	// Prysm constants.
 	GenesisValidatorsRoot:          [32]byte{75, 54, 61, 185, 78, 40, 97, 32, 215, 110, 185, 5, 52, 15, 221, 78, 84, 191, 233, 240, 107, 243, 63, 246, 207, 90, 210, 127, 81, 27, 254, 149},

consensus-types/BUILD.bazel

@@ -2,10 +2,15 @@ load("@prysm//tools/go:def.bzl", "go_library")
 
 go_library(
     name = "go_default_library",
-    srcs = ["types.go"],
+    srcs = [
+        "indexed_payload_attestation.go",
+        "types.go",
+    ],
     importpath = "github.com/OffchainLabs/prysm/v7/consensus-types",
     visibility = ["//visibility:public"],
     deps = [
+        "//consensus-types/primitives:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],

consensus-types/indexed_payload_attestation.go

@@ -0,0 +1,36 @@
+package consensus_types
+
+import (
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+)
+
+type IndexedPayloadAttestation struct {
+	AttestingIndices []primitives.ValidatorIndex
+	Data             *eth.PayloadAttestationData
+	Signature        []byte
+}
+
+// GetAttestingIndices returns the attesting indices or nil when the receiver is nil.
+func (x *IndexedPayloadAttestation) GetAttestingIndices() []primitives.ValidatorIndex {
+	if x == nil {
+		return nil
+	}
+	return x.AttestingIndices
+}
+
+// GetData returns the attestation data or nil when the receiver is nil.
+func (x *IndexedPayloadAttestation) GetData() *eth.PayloadAttestationData {
+	if x == nil {
+		return nil
+	}
+	return x.Data
+}
+
+// GetSignature returns the signature bytes or nil when the receiver is nil.
+func (x *IndexedPayloadAttestation) GetSignature() []byte {
+	if x == nil {
+		return nil
+	}
+	return x.Signature
+}

testing/spectest/mainnet/BUILD.bazel

@@ -202,6 +202,7 @@ go_test(
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
         "gloas__operations__execution_payload_header_test.go",
+        "gloas__operations__payload_attestation_test.go",
         "gloas__operations__proposer_slashing_test.go",
         "gloas__sanity__slots_test.go",
         "gloas__ssz_static__ssz_static_test.go",

testing/spectest/mainnet/gloas__operations__payload_attestation_test.go

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

testing/spectest/minimal/BUILD.bazel

@@ -208,6 +208,7 @@ go_test(
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
         "gloas__operations__execution_payload_bid_test.go",
+        "gloas__operations__payload_attestation_test.go",
         "gloas__operations__proposer_slashing_test.go",
         "gloas__sanity__slots_test.go",
         "gloas__ssz_static__ssz_static_test.go",

testing/spectest/minimal/gloas__operations__payload_attestation_test.go

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

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

@@ -13,6 +13,7 @@ go_library(
         "deposit_request.go",
         "execution_payload.go",
         "execution_payload_bid.go",
+        "payload_attestation.go",
         "proposer_slashing.go",
         "slashing.go",
         "sync_aggregate.go",

testing/spectest/shared/common/operations/payload_attestation.go

@@ -0,0 +1,122 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"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/state"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/utils"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+	"github.com/golang/snappy"
+)
+
+type PayloadAttestationOperation func(ctx context.Context, s state.BeaconState, att *eth.PayloadAttestation) (state.BeaconState, error)
+
+func RunPayloadAttestationTest(t *testing.T, config string, fork string, sszToState SSZToState) {
+	runPayloadAttestationTest(t, config, fork, "payload_attestation", sszToState, func(ctx context.Context, s state.BeaconState, att *eth.PayloadAttestation) (state.BeaconState, error) {
+		// Create a mock block body with the payload attestation
+		body, err := createMockBlockBodyWithPayloadAttestation(att)
+		if err != nil {
+			return s, err
+		}
+		// Wrap the protobuf body in the interface
+		wrappedBody, err := blocks.NewBeaconBlockBody(body)
+		if err != nil {
+			return s, err
+		}
+		err = gloas.ProcessPayloadAttestations(ctx, s, wrappedBody)
+		return s, err
+	})
+}
+
+func runPayloadAttestationTest(t *testing.T, config string, fork string, objName string, sszToState SSZToState, operationFn PayloadAttestationOperation) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/"+objName+"/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/"+objName+"/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			helpers.ClearCache()
+			folderPath := path.Join(testsFolderPath, folder.Name())
+
+			// Load payload attestation from payload_attestation.ssz_snappy
+			attestationFile, err := util.BazelFileBytes(folderPath, "payload_attestation.ssz_snappy")
+			require.NoError(t, err)
+			attestationSSZ, err := snappy.Decode(nil /* dst */, attestationFile)
+			require.NoError(t, err, "Failed to decompress payload attestation")
+
+			// Unmarshal payload attestation
+			att := &eth.PayloadAttestation{}
+			err = att.UnmarshalSSZ(attestationSSZ)
+			require.NoError(t, err, "Failed to unmarshal payload attestation")
+
+			runPayloadAttestationOperationTest(t, folderPath, att, sszToState, operationFn)
+		})
+	}
+}
+
+// runPayloadAttestationOperationTest runs a single payload attestation operation test
+func runPayloadAttestationOperationTest(t *testing.T, folderPath string, att *eth.PayloadAttestation, sszToState SSZToState, operationFn PayloadAttestationOperation) {
+	preBeaconStateFile, err := util.BazelFileBytes(folderPath, "pre.ssz_snappy")
+	require.NoError(t, err)
+	preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
+	require.NoError(t, err, "Failed to decompress")
+	beaconState, err := sszToState(preBeaconStateSSZ)
+	require.NoError(t, err)
+
+	// Check if post state exists
+	postStateExists := true
+	postBeaconStateFile, err := util.BazelFileBytes(folderPath, "post.ssz_snappy")
+	if err != nil {
+		postStateExists = false
+	}
+
+	ctx := t.Context()
+	resultState, err := operationFn(ctx, beaconState, att)
+
+	if postStateExists {
+		// Test should succeed
+		require.NoError(t, err, "Operation should succeed")
+
+		// Compare with expected post state
+		postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
+		require.NoError(t, err, "Failed to decompress post state")
+		expectedState, err := sszToState(postBeaconStateSSZ)
+		require.NoError(t, err)
+
+		expectedRoot, err := expectedState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		resultRoot, err := resultState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		require.DeepEqual(t, expectedRoot, resultRoot, "Post state does not match expected")
+	} else {
+		// Test should fail (no post.ssz_snappy means the operation should error)
+		require.NotNil(t, err, "Operation should fail but succeeded")
+	}
+}
+
+// createMockBlockBodyWithPayloadAttestation creates a mock block body containing the payload attestation
+func createMockBlockBodyWithPayloadAttestation(att *eth.PayloadAttestation) (*eth.BeaconBlockBodyGloas, error) {
+	body := &eth.BeaconBlockBodyGloas{
+		PayloadAttestations: []*eth.PayloadAttestation{att},
+		// Default values
+		RandaoReveal:          make([]byte, 96),
+		Eth1Data:              &eth.Eth1Data{},
+		Graffiti:              make([]byte, 32),
+		ProposerSlashings:     []*eth.ProposerSlashing{},
+		AttesterSlashings:     []*eth.AttesterSlashingElectra{},
+		Attestations:          []*eth.AttestationElectra{},
+		Deposits:              []*eth.Deposit{},
+		VoluntaryExits:        []*eth.SignedVoluntaryExit{},
+		SyncAggregate:         &eth.SyncAggregate{},
+		BlsToExecutionChanges: []*eth.SignedBLSToExecutionChange{},
+	}
+	return body, nil
+}

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

@@ -6,6 +6,7 @@ go_library(
     srcs = [
         "execution_payload_bid.go",
         "helpers.go",
+        "payload_attestation.go",
         "proposer_slashing.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations",

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

@@ -15,7 +15,6 @@ func sszToState(b []byte) (state.BeaconState, error) {
 	}
 	return state_native.InitializeFromProtoGloas(base)
 }
-
 func sszToBlock(b []byte) (interfaces.SignedBeaconBlock, error) {
 	base := &ethpb.BeaconBlockGloas{}
 	if err := base.UnmarshalSSZ(b); err != nil {

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

@@ -0,0 +1,12 @@
+package operations
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	common "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/common/operations"
+)
+
+func RunPayloadAttestationTest(t *testing.T, config string) {
+	common.RunPayloadAttestationTest(t, config, version.String(version.Gloas), sszToState)
+}

testing/util/state.go

@@ -112,7 +112,7 @@ func NewBeaconState(options ...NewBeaconStateOption) (state.BeaconState, error)
 		return nil, err
 	}
 
-	return st, nil
+	return st.Copy(), nil
 }
 
 // NewBeaconStateAltair creates a beacon state with minimum marshalable fields.
@@ -167,7 +167,7 @@ func NewBeaconStateAltair(options ...func(state *ethpb.BeaconStateAltair) error)
 		return nil, err
 	}
 
-	return st, nil
+	return st.Copy(), nil
 }
 
 // NewBeaconStateBellatrix creates a beacon state with minimum marshalable fields.
@@ -234,7 +234,7 @@ func NewBeaconStateBellatrix(options ...func(state *ethpb.BeaconStateBellatrix)
 		return nil, err
 	}
 
-	return st, nil
+	return st.Copy(), nil
 }
 
 // NewBeaconStateCapella creates a beacon state with minimum marshalable fields.
@@ -302,7 +302,7 @@ func NewBeaconStateCapella(options ...func(state *ethpb.BeaconStateCapella) erro
 		return nil, err
 	}
 
-	return st, nil
+	return st.Copy(), nil
 }
 
 // NewBeaconStateDeneb creates a beacon state with minimum marshalable fields.
@@ -370,7 +370,7 @@ func NewBeaconStateDeneb(options ...func(state *ethpb.BeaconStateDeneb) error) (
 		return nil, err
 	}
 
-	return st, nil
+	return st.Copy(), nil
 }
 
 // NewBeaconStateElectra creates a beacon state with minimum marshalable fields.
@@ -438,7 +438,7 @@ func NewBeaconStateElectra(options ...func(state *ethpb.BeaconStateElectra) erro
 		return nil, err
 	}
 
-	return st, nil
+	return st.Copy(), nil
 }
 
 // NewBeaconStateFulu creates a beacon state with minimum marshalable fields.
@@ -507,86 +507,7 @@ func NewBeaconStateFulu(options ...func(state *ethpb.BeaconStateFulu) error) (st
 		return nil, err
 	}
 
-	return st, nil
-}
-
-// NewBeaconStateGloas creates a beacon state with minimum marshalable fields.
-func NewBeaconStateGloas(options ...func(state *ethpb.BeaconStateGloas) error) (state.BeaconState, error) {
-	pubkeys := make([][]byte, 512)
-	for i := range pubkeys {
-		pubkeys[i] = make([]byte, 48)
-	}
-
-	builderPendingPayments := make([]*ethpb.BuilderPendingPayment, 64)
-	for i := range builderPendingPayments {
-		builderPendingPayments[i] = &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		}
-	}
-
-	seed := &ethpb.BeaconStateGloas{
-		BlockRoots:                 filledByteSlice2D(uint64(params.BeaconConfig().SlotsPerHistoricalRoot), 32),
-		StateRoots:                 filledByteSlice2D(uint64(params.BeaconConfig().SlotsPerHistoricalRoot), 32),
-		Slashings:                  make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
-		RandaoMixes:                filledByteSlice2D(uint64(params.BeaconConfig().EpochsPerHistoricalVector), 32),
-		Validators:                 make([]*ethpb.Validator, 0),
-		CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-		Eth1Data: &ethpb.Eth1Data{
-			DepositRoot: make([]byte, fieldparams.RootLength),
-			BlockHash:   make([]byte, 32),
-		},
-		Fork: &ethpb.Fork{
-			PreviousVersion: make([]byte, 4),
-			CurrentVersion:  make([]byte, 4),
-		},
-		Eth1DataVotes:               make([]*ethpb.Eth1Data, 0),
-		HistoricalRoots:             make([][]byte, 0),
-		JustificationBits:           bitfield.Bitvector4{0x0},
-		FinalizedCheckpoint:         &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-		LatestBlockHeader:           HydrateBeaconHeader(&ethpb.BeaconBlockHeader{}),
-		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-		PreviousEpochParticipation:  make([]byte, 0),
-		CurrentEpochParticipation:   make([]byte, 0),
-		CurrentSyncCommittee: &ethpb.SyncCommittee{
-			Pubkeys:         pubkeys,
-			AggregatePubkey: make([]byte, 48),
-		},
-		NextSyncCommittee: &ethpb.SyncCommittee{
-			Pubkeys:         pubkeys,
-			AggregatePubkey: make([]byte, 48),
-		},
-		ProposerLookahead: make([]uint64, 64),
-		LatestExecutionPayloadBid: &ethpb.ExecutionPayloadBid{
-			ParentBlockHash:        make([]byte, 32),
-			ParentBlockRoot:        make([]byte, 32),
-			BlockHash:              make([]byte, 32),
-			PrevRandao:             make([]byte, 32),
-			FeeRecipient:           make([]byte, 20),
-			BlobKzgCommitmentsRoot: make([]byte, 32),
-		},
-		Builders:                     make([]*ethpb.Builder, 0),
-		ExecutionPayloadAvailability: make([]byte, 1024),
-		BuilderPendingPayments:       builderPendingPayments,
-		BuilderPendingWithdrawals:    make([]*ethpb.BuilderPendingWithdrawal, 0),
-		LatestBlockHash:              make([]byte, 32),
-		PayloadExpectedWithdrawals:   make([]*enginev1.Withdrawal, 0),
-	}
-
-	for _, opt := range options {
-		err := opt(seed)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	var st, err = state_native.InitializeFromProtoUnsafeGloas(seed)
-	if err != nil {
-		return nil, err
-	}
-
-	return st, nil
+	return st.Copy(), nil
 }
 
 // SSZ will fill 2D byte slices with their respective values, so we must fill these in too for round

testing/util/state_test.go

@@ -68,26 +68,6 @@ func TestNewBeaconStateElectra(t *testing.T) {
 	assert.DeepEqual(t, st.ToProtoUnsafe(), got)
 }
 
-func TestNewBeaconStateFulu(t *testing.T) {
-	st, err := NewBeaconStateFulu()
-	require.NoError(t, err)
-	b, err := st.MarshalSSZ()
-	require.NoError(t, err)
-	got := &ethpb.BeaconStateFulu{}
-	require.NoError(t, got.UnmarshalSSZ(b))
-	assert.DeepEqual(t, st.ToProtoUnsafe(), got)
-}
-
-func TestNewBeaconStateGloas(t *testing.T) {
-	st, err := NewBeaconStateGloas()
-	require.NoError(t, err)
-	b, err := st.MarshalSSZ()
-	require.NoError(t, err)
-	got := &ethpb.BeaconStateGloas{}
-	require.NoError(t, got.UnmarshalSSZ(b))
-	assert.DeepEqual(t, st.ToProtoUnsafe(), got)
-}
-
 func TestNewBeaconState_HashTreeRoot(t *testing.T) {
 	st, err := NewBeaconState()
 	require.NoError(t, err)