gloas: add new process payload attestation

beacon-chain/core/gloas/BUILD.bazel

@@ -2,19 +2,21 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = ["payload.go"],
+    srcs = ["payload_attestation.go"],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
     visibility = ["//visibility:public"],
     deps = [
-        "//beacon-chain/core/electra:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing: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/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
-        "//encoding/ssz:go_default_library",
-        "//proto/engine/v1: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",
@@ -23,21 +25,22 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = ["payload_test.go"],
+    srcs = ["payload_attestation_test.go"],
     embed = [":go_default_library"],
     deps = [
+        "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//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",
-        "//encoding/ssz:go_default_library",
-        "//proto/engine/v1:go_default_library",
+        "//crypto/bls/common:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],
 )

beacon-chain/core/gloas/payload.go

@@ -1,341 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
-	"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/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
-)
-
-// ProcessExecutionPayload processes the signed execution payload envelope for the Gloas fork.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// def process_execution_payload(
-//
-//	state: BeaconState,
-//	signed_envelope: SignedExecutionPayloadEnvelope,
-//	execution_engine: ExecutionEngine,
-//	verify: bool = True,
-//
-// ) -> None:
-//
-//	envelope = signed_envelope.message
-//	payload = envelope.payload
-//
-//	if verify:
-//	    assert verify_execution_payload_envelope_signature(state, signed_envelope)
-//
-//	previous_state_root = hash_tree_root(state)
-//	if state.latest_block_header.state_root == Root():
-//	    state.latest_block_header.state_root = previous_state_root
-//
-//	assert envelope.beacon_block_root == hash_tree_root(state.latest_block_header)
-//	assert envelope.slot == state.slot
-//
-//	committed_bid = state.latest_execution_payload_bid
-//	assert envelope.builder_index == committed_bid.builder_index
-//	assert committed_bid.blob_kzg_commitments_root == hash_tree_root(envelope.blob_kzg_commitments)
-//	assert committed_bid.prev_randao == payload.prev_randao
-//
-//	assert hash_tree_root(payload.withdrawals) == hash_tree_root(state.payload_expected_withdrawals)
-//
-//	assert committed_bid.gas_limit == payload.gas_limit
-//	assert committed_bid.block_hash == payload.block_hash
-//	assert payload.parent_hash == state.latest_block_hash
-//	assert payload.timestamp == compute_time_at_slot(state, state.slot)
-//	assert (
-//	    len(envelope.blob_kzg_commitments)
-//	    <= get_blob_parameters(get_current_epoch(state)).max_blobs_per_block
-//	)
-//	versioned_hashes = [
-//	    kzg_commitment_to_versioned_hash(commitment) for commitment in envelope.blob_kzg_commitments
-//	]
-//	requests = envelope.execution_requests
-//	assert execution_engine.verify_and_notify_new_payload(
-//	    NewPayloadRequest(
-//	        execution_payload=payload,
-//	        versioned_hashes=versioned_hashes,
-//	        parent_beacon_block_root=state.latest_block_header.parent_root,
-//	        execution_requests=requests,
-//	    )
-//	)
-//
-//	for op in requests.deposits: process_deposit_request(state, op)
-//	for op in requests.withdrawals: process_withdrawal_request(state, op)
-//	for op in requests.consolidations: process_consolidation_request(state, op)
-//
-//	payment = state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH]
-//	amount = payment.withdrawal.amount
-//	if amount > 0:
-//	    state.builder_pending_withdrawals.append(payment.withdrawal)
-//	state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH] = (
-//	    BuilderPendingPayment()
-//	)
-//
-//	state.execution_payload_availability[state.slot % SLOTS_PER_HISTORICAL_ROOT] = 0b1
-//	state.latest_block_hash = payload.block_hash
-//
-//	if verify:
-//	    assert envelope.state_root == hash_tree_root(state)
-func ProcessExecutionPayload(
-	ctx context.Context,
-	st state.BeaconState,
-	signedEnvelope interfaces.ROSignedExecutionPayloadEnvelope,
-) error {
-	// Verify the signature on the signed execution payload envelope
-	if err := verifyExecutionPayloadEnvelopeSignature(st, signedEnvelope); err != nil {
-		return errors.Wrap(err, "signature verification failed")
-	}
-
-	envelope, err := signedEnvelope.Envelope()
-	if err != nil {
-		return errors.Wrap(err, "could not get envelope from signed envelope")
-	}
-	payload, err := envelope.Execution()
-	if err != nil {
-		return errors.Wrap(err, "could not get execution payload from envelope")
-	}
-
-	latestHeader := st.LatestBlockHeader()
-	if len(latestHeader.StateRoot) == 0 || bytes.Equal(latestHeader.StateRoot, make([]byte, 32)) {
-		previousStateRoot, err := st.HashTreeRoot(ctx)
-		if err != nil {
-			return errors.Wrap(err, "could not compute state root")
-		}
-		latestHeader.StateRoot = previousStateRoot[:]
-		if err := st.SetLatestBlockHeader(latestHeader); err != nil {
-			return errors.Wrap(err, "could not set latest block header")
-		}
-	}
-
-	blockHeaderRoot, err := latestHeader.HashTreeRoot()
-	if err != nil {
-		return errors.Wrap(err, "could not compute block header root")
-	}
-	beaconBlockRoot := envelope.BeaconBlockRoot()
-	if !bytes.Equal(beaconBlockRoot[:], blockHeaderRoot[:]) {
-		return errors.Errorf("envelope beacon block root does not match state latest block header root: envelope=%#x, header=%#x", beaconBlockRoot, blockHeaderRoot)
-	}
-
-	if envelope.Slot() != st.Slot() {
-		return errors.Errorf("envelope slot does not match state slot: envelope=%d, state=%d", envelope.Slot(), st.Slot())
-	}
-
-	latestBid, err := st.LatestExecutionPayloadBid()
-	if err != nil {
-		return errors.Wrap(err, "could not get latest execution payload bid")
-	}
-	if latestBid == nil {
-		return errors.New("latest execution payload bid is nil")
-	}
-	if envelope.BuilderIndex() != latestBid.BuilderIndex() {
-		return errors.Errorf("envelope builder index does not match committed bid builder index: envelope=%d, bid=%d", envelope.BuilderIndex(), latestBid.BuilderIndex())
-	}
-
-	envelopeBlobCommitments := envelope.BlobKzgCommitments()
-	envelopeBlobRoot, err := ssz.KzgCommitmentsRoot(envelopeBlobCommitments)
-	if err != nil {
-		return errors.Wrap(err, "could not compute envelope blob KZG commitments root")
-	}
-	committedBlobRoot := latestBid.BlobKzgCommitmentsRoot()
-	if !bytes.Equal(committedBlobRoot[:], envelopeBlobRoot[:]) {
-		return errors.Errorf("committed bid blob KZG commitments root does not match envelope: bid=%#x, envelope=%#x", committedBlobRoot, envelopeBlobRoot)
-	}
-
-	withdrawals, err := payload.Withdrawals()
-	if err != nil {
-		return errors.Wrap(err, "could not get withdrawals from payload")
-	}
-	cfg := params.BeaconConfig()
-	withdrawalsRoot, err := ssz.WithdrawalSliceRoot(withdrawals, cfg.MaxWithdrawalsPerPayload)
-	if err != nil {
-		return errors.Wrap(err, "could not compute withdrawals root")
-	}
-
-	expectedWithdrawals, err := st.PayloadExpectedWithdrawals()
-	if err != nil {
-		return errors.Wrap(err, "could not get expected withdrawals")
-	}
-	expectedRoot, err := ssz.WithdrawalSliceRoot(expectedWithdrawals, cfg.MaxWithdrawalsPerPayload)
-	if err != nil {
-		return errors.Wrap(err, "could not compute expected withdrawals root")
-	}
-	if !bytes.Equal(withdrawalsRoot[:], expectedRoot[:]) {
-		return errors.Errorf("payload withdrawals root does not match expected withdrawals: payload=%#x, expected=%#x", withdrawalsRoot, expectedRoot)
-	}
-
-	if latestBid.GasLimit() != payload.GasLimit() {
-		return errors.Errorf("committed bid gas limit does not match payload gas limit: bid=%d, payload=%d", latestBid.GasLimit(), payload.GasLimit())
-	}
-
-	latestBidPrevRandao := latestBid.PrevRandao()
-	if !bytes.Equal(payload.PrevRandao(), latestBidPrevRandao[:]) {
-		return errors.Errorf("payload prev randao does not match committed bid prev randao: payload=%#x, bid=%#x", payload.PrevRandao(), latestBidPrevRandao)
-	}
-
-	bidBlockHash := latestBid.BlockHash()
-	payloadBlockHash := payload.BlockHash()
-	if !bytes.Equal(bidBlockHash[:], payloadBlockHash) {
-		return errors.Errorf("committed bid block hash does not match payload block hash: bid=%#x, payload=%#x", bidBlockHash, payloadBlockHash)
-	}
-
-	latestBlockHash, err := st.LatestBlockHash()
-	if err != nil {
-		return errors.Wrap(err, "could not get latest block hash")
-	}
-	if !bytes.Equal(payload.ParentHash(), latestBlockHash[:]) {
-		return errors.Errorf("payload parent hash does not match state latest block hash: payload=%#x, state=%#x", payload.ParentHash(), latestBlockHash)
-	}
-
-	t, err := slots.StartTime(st.GenesisTime(), st.Slot())
-	if err != nil {
-		return errors.Wrap(err, "could not compute timestamp")
-	}
-	if payload.Timestamp() != uint64(t.Unix()) {
-		return errors.Errorf("payload timestamp does not match expected timestamp: payload=%d, expected=%d", payload.Timestamp(), uint64(t.Unix()))
-	}
-
-	maxBlobsPerBlock := cfg.MaxBlobsPerBlock(envelope.Slot())
-	if len(envelopeBlobCommitments) > maxBlobsPerBlock {
-		return errors.Errorf("too many blob KZG commitments: got=%d, max=%d", len(envelopeBlobCommitments), maxBlobsPerBlock)
-	}
-
-	if err := processExecutionRequests(ctx, st, envelope.ExecutionRequests()); err != nil {
-		return errors.Wrap(err, "could not process execution requests")
-	}
-
-	if err := queueBuilderPayment(ctx, st); err != nil {
-		return errors.Wrap(err, "could not queue builder payment")
-	}
-
-	if err := st.SetExecutionPayloadAvailability(st.Slot(), true); err != nil {
-		return errors.Wrap(err, "could not set execution payload availability")
-	}
-
-	if err := st.SetLatestBlockHash([32]byte(payload.BlockHash())); err != nil {
-		return errors.Wrap(err, "could not set latest block hash")
-	}
-
-	r, err := st.HashTreeRoot(ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get hash tree root")
-	}
-	if r != envelope.StateRoot() {
-		return fmt.Errorf("state root mismatch: expected %#x, got %#x", envelope.StateRoot(), r)
-	}
-
-	return nil
-}
-
-// processExecutionRequests processes deposits, withdrawals, and consolidations from execution requests.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// for op in requests.deposits: process_deposit_request(state, op)
-// for op in requests.withdrawals: process_withdrawal_request(state, op)
-// for op in requests.consolidations: process_consolidation_request(state, op)
-func processExecutionRequests(ctx context.Context, st state.BeaconState, requests *enginev1.ExecutionRequests) error {
-	var err error
-	st, err = electra.ProcessDepositRequests(ctx, st, requests.Deposits)
-	if err != nil {
-		return errors.Wrap(err, "could not process deposit requests")
-	}
-
-	st, err = electra.ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
-	if err != nil {
-		return errors.Wrap(err, "could not process withdrawal requests")
-	}
-	err = electra.ProcessConsolidationRequests(ctx, st, requests.Consolidations)
-	if err != nil {
-		return errors.Wrap(err, "could not process consolidation requests")
-	}
-	return nil
-}
-
-// queueBuilderPayment implements the builder payment queuing logic for Gloas.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// payment = state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH]
-// amount = payment.withdrawal.amount
-// if amount > 0:
-//
-//	state.builder_pending_withdrawals.append(payment.withdrawal)
-//
-// state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH] = BuilderPendingPayment()
-func queueBuilderPayment(ctx context.Context, st state.BeaconState) error {
-	slot := st.Slot()
-	payment, err := st.BuilderPendingPayment(slot)
-	if err != nil {
-		return errors.Wrap(err, "could not get builder pending payment")
-	}
-
-	if payment.Withdrawal != nil && payment.Withdrawal.Amount > 0 {
-		if err := st.AppendBuilderPendingWithdrawal(payment.Withdrawal); err != nil {
-			return errors.Wrap(err, "could not append builder pending withdrawal")
-		}
-	}
-
-	reset := &ethpb.BuilderPendingPayment{
-		Withdrawal: &ethpb.BuilderPendingWithdrawal{
-			FeeRecipient: make([]byte, 20),
-		},
-	}
-	if err := st.SetBuilderPendingPayment(slot, reset); err != nil {
-		return errors.Wrap(err, "could not set builder pending payment")
-	}
-
-	return nil
-}
-
-// verifyExecutionPayloadEnvelopeSignature verifies the BLS signature on a signed execution payload envelope.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// if verify: assert verify_execution_payload_envelope_signature(state, signed_envelope)
-func verifyExecutionPayloadEnvelopeSignature(st state.BeaconState, signedEnvelope interfaces.ROSignedExecutionPayloadEnvelope) error {
-	envelope, err := signedEnvelope.Envelope()
-	if err != nil {
-		return fmt.Errorf("failed to get envelope: %w", err)
-	}
-
-	builderIdx := envelope.BuilderIndex()
-	builderPubkey := st.PubkeyAtIndex(primitives.ValidatorIndex(builderIdx))
-	publicKey, err := bls.PublicKeyFromBytes(builderPubkey[:])
-	if err != nil {
-		return fmt.Errorf("invalid builder public key: %w", err)
-	}
-
-	signatureBytes := signedEnvelope.Signature()
-	signature, err := bls.SignatureFromBytes(signatureBytes[:])
-	if err != nil {
-		return fmt.Errorf("invalid signature format: %w", err)
-	}
-
-	currentEpoch := slots.ToEpoch(envelope.Slot())
-	domain, err := signing.Domain(
-		st.Fork(),
-		currentEpoch,
-		params.BeaconConfig().DomainBeaconBuilder,
-		st.GenesisValidatorsRoot(),
-	)
-	if err != nil {
-		return fmt.Errorf("failed to compute signing domain: %w", err)
-	}
-
-	signingRoot, err := signedEnvelope.SigningRoot(domain)
-	if err != nil {
-		return fmt.Errorf("failed to compute signing root: %w", err)
-	}
-
-	if !signature.Verify(publicKey, signingRoot[:]) {
-		return fmt.Errorf("signature verification failed: %w", signing.ErrSigFailedToVerify)
-	}
-
-	return nil
-}

beacon-chain/core/gloas/payload_attestation.go

@@ -0,0 +1,243 @@
+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)
+		}
+		if data.Slot+1 != 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, committeesPerSlot*(activeCount/committeesPerSlot))
+
+	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(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):
+//
+//	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(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()
+	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++ {
+		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:])) // 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, None)),
+//	    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(st.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,241 @@
+package gloas
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/OffchainLabs/go-bitfield"
+	"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 := 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 := 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 := ProcessPayloadAttestations(t.Context(), st, body)
+	require.ErrorContains(t, "failed to verify indexed form", err)
+	require.ErrorContains(t, "invalid signature", 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 := 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 := 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, att *eth.PayloadAttestation) interfaces.ReadOnlyBeaconBlockBody {
+	body := &eth.BeaconBlockBodyGloas{
+		PayloadAttestations:   []*eth.PayloadAttestation{att},
+		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(st.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/core/gloas/payload_test.go

@@ -1,269 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"context"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	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/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/encoding/ssz"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-type payloadFixture struct {
-	state       state.BeaconState
-	signed      interfaces.ROSignedExecutionPayloadEnvelope
-	signedProto *ethpb.SignedExecutionPayloadEnvelope
-	envelope    *ethpb.ExecutionPayloadEnvelope
-	payload     *enginev1.ExecutionPayloadDeneb
-	slot        primitives.Slot
-}
-
-func buildPayloadFixture(t *testing.T, mutate func(payload *enginev1.ExecutionPayloadDeneb, bid *ethpb.ExecutionPayloadBid, envelope *ethpb.ExecutionPayloadEnvelope)) payloadFixture {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	slot := primitives.Slot(5)
-	builderIdx := primitives.BuilderIndex(0)
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	pk := sk.PublicKey().Marshal()
-
-	randao := bytes.Repeat([]byte{0xAA}, 32)
-	parentHash := bytes.Repeat([]byte{0xBB}, 32)
-	blockHash := bytes.Repeat([]byte{0xCC}, 32)
-
-	withdrawals := []*enginev1.Withdrawal{
-		{Index: 0, ValidatorIndex: 1, Address: bytes.Repeat([]byte{0x01}, 20), Amount: 0},
-	}
-
-	blobCommitments := [][]byte{}
-	blobRoot, err := ssz.KzgCommitmentsRoot(blobCommitments)
-	require.NoError(t, err)
-
-	payload := &enginev1.ExecutionPayloadDeneb{
-		ParentHash:    parentHash,
-		FeeRecipient:  bytes.Repeat([]byte{0x01}, 20),
-		StateRoot:     bytes.Repeat([]byte{0x02}, 32),
-		ReceiptsRoot:  bytes.Repeat([]byte{0x03}, 32),
-		LogsBloom:     bytes.Repeat([]byte{0x04}, 256),
-		PrevRandao:    randao,
-		BlockNumber:   1,
-		GasLimit:      1,
-		GasUsed:       0,
-		Timestamp:     100,
-		ExtraData:     []byte{},
-		BaseFeePerGas: bytes.Repeat([]byte{0x05}, 32),
-		BlockHash:     blockHash,
-		Transactions:  [][]byte{},
-		Withdrawals:   withdrawals,
-		BlobGasUsed:   0,
-		ExcessBlobGas: 0,
-	}
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        parentHash,
-		ParentBlockRoot:        bytes.Repeat([]byte{0xDD}, 32),
-		BlockHash:              blockHash,
-		PrevRandao:             randao,
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  0,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: blobRoot[:],
-		FeeRecipient:           bytes.Repeat([]byte{0xEE}, 20),
-	}
-
-	header := &ethpb.BeaconBlockHeader{
-		Slot:       slot,
-		ParentRoot: bytes.Repeat([]byte{0x11}, 32),
-		StateRoot:  bytes.Repeat([]byte{0x22}, 32),
-		BodyRoot:   bytes.Repeat([]byte{0x33}, 32),
-	}
-	headerRoot, err := header.HashTreeRoot()
-	require.NoError(t, err)
-
-	envelope := &ethpb.ExecutionPayloadEnvelope{
-		Slot:               slot,
-		BuilderIndex:       builderIdx,
-		BeaconBlockRoot:    headerRoot[:],
-		Payload:            payload,
-		BlobKzgCommitments: blobCommitments,
-		ExecutionRequests:  &enginev1.ExecutionRequests{},
-	}
-
-	if mutate != nil {
-		mutate(payload, bid, envelope)
-	}
-
-	genesisRoot := bytes.Repeat([]byte{0xAB}, 32)
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range blockRoots {
-		blockRoots[i] = bytes.Repeat([]byte{0x44}, 32)
-		stateRoots[i] = bytes.Repeat([]byte{0x55}, 32)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = randao
-	}
-
-	withdrawalCreds := make([]byte, 32)
-	withdrawalCreds[0] = cfg.ETH1AddressWithdrawalPrefixByte
-
-	eth1Data := &ethpb.Eth1Data{
-		DepositRoot:  bytes.Repeat([]byte{0x66}, 32),
-		DepositCount: 0,
-		BlockHash:    bytes.Repeat([]byte{0x77}, 32),
-	}
-
-	vals := []*ethpb.Validator{
-		{
-			PublicKey:             pk,
-			WithdrawalCredentials: withdrawalCreds,
-			EffectiveBalance:      cfg.MinActivationBalance + 1_000,
-		},
-	}
-	balances := []uint64{cfg.MinActivationBalance + 1_000}
-
-	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
-	for i := range payments {
-		payments[i] = &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		}
-	}
-
-	executionPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-
-	genesisTime := uint64(0)
-	slotSeconds := cfg.SecondsPerSlot * uint64(slot)
-	if payload.Timestamp > slotSeconds {
-		genesisTime = payload.Timestamp - slotSeconds
-	}
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                  slot,
-		GenesisTime:           genesisTime,
-		GenesisValidatorsRoot: genesisRoot,
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
-			Epoch:           0,
-		},
-		LatestBlockHeader:            header,
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		Eth1Data:                     eth1Data,
-		Validators:                   vals,
-		Balances:                     balances,
-		LatestBlockHash:              payload.ParentHash,
-		LatestExecutionPayloadBid:    bid,
-		BuilderPendingPayments:       payments,
-		ExecutionPayloadAvailability: executionPayloadAvailability,
-		BuilderPendingWithdrawals:    []*ethpb.BuilderPendingWithdrawal{},
-		PayloadExpectedWithdrawals:   payload.Withdrawals,
-	}
-
-	st, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-
-	expected := st.Copy()
-	ctx := context.Background()
-	require.NoError(t, processExecutionRequests(ctx, expected, envelope.ExecutionRequests))
-	require.NoError(t, queueBuilderPayment(ctx, expected))
-	require.NoError(t, expected.SetExecutionPayloadAvailability(slot, true))
-	var blockHashArr [32]byte
-	copy(blockHashArr[:], payload.BlockHash)
-	require.NoError(t, expected.SetLatestBlockHash(blockHashArr))
-	expectedRoot, err := expected.HashTreeRoot(ctx)
-	require.NoError(t, err)
-	envelope.StateRoot = expectedRoot[:]
-
-	epoch := slots.ToEpoch(slot)
-	domain, err := signing.Domain(st.Fork(), epoch, cfg.DomainBeaconBuilder, st.GenesisValidatorsRoot())
-	require.NoError(t, err)
-	signingRoot, err := signing.ComputeSigningRoot(envelope, domain)
-	require.NoError(t, err)
-	signature := sk.Sign(signingRoot[:]).Marshal()
-
-	signedProto := &ethpb.SignedExecutionPayloadEnvelope{
-		Message:   envelope,
-		Signature: signature,
-	}
-	signed, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
-	require.NoError(t, err)
-
-	return payloadFixture{
-		state:       st,
-		signed:      signed,
-		signedProto: signedProto,
-		envelope:    envelope,
-		payload:     payload,
-		slot:        slot,
-	}
-}
-
-func TestProcessExecutionPayload_Success(t *testing.T) {
-	fixture := buildPayloadFixture(t, nil)
-	require.NoError(t, ProcessExecutionPayload(t.Context(), fixture.state, fixture.signed))
-
-	latestHash, err := fixture.state.LatestBlockHash()
-	require.NoError(t, err)
-	var expectedHash [32]byte
-	copy(expectedHash[:], fixture.payload.BlockHash)
-	require.Equal(t, expectedHash, latestHash)
-
-	payment, err := fixture.state.BuilderPendingPayment(fixture.slot)
-	require.NoError(t, err)
-	require.NotNil(t, payment)
-	require.Equal(t, primitives.Gwei(0), payment.Withdrawal.Amount)
-}
-
-func TestProcessExecutionPayload_PrevRandaoMismatch(t *testing.T) {
-	fixture := buildPayloadFixture(t, func(_ *enginev1.ExecutionPayloadDeneb, bid *ethpb.ExecutionPayloadBid, _ *ethpb.ExecutionPayloadEnvelope) {
-		bid.PrevRandao = bytes.Repeat([]byte{0xFF}, 32)
-	})
-
-	err := ProcessExecutionPayload(t.Context(), fixture.state, fixture.signed)
-	require.ErrorContains(t, "prev randao", err)
-}
-
-func TestQueueBuilderPayment_ZeroAmountClearsSlot(t *testing.T) {
-	fixture := buildPayloadFixture(t, nil)
-
-	require.NoError(t, queueBuilderPayment(t.Context(), fixture.state))
-
-	payment, err := fixture.state.BuilderPendingPayment(fixture.slot)
-	require.NoError(t, err)
-	require.NotNil(t, payment)
-	require.Equal(t, primitives.Gwei(0), payment.Withdrawal.Amount)
-}
-
-func TestVerifyExecutionPayloadEnvelopeSignature_InvalidSig(t *testing.T) {
-	fixture := buildPayloadFixture(t, nil)
-
-	signedProto := &ethpb.SignedExecutionPayloadEnvelope{
-		Message:   fixture.signedProto.Message,
-		Signature: bytes.Repeat([]byte{0xFF}, 96),
-	}
-	badSigned, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
-	require.NoError(t, err)
-
-	err = verifyExecutionPayloadEnvelopeSignature(fixture.state, badSigned)
-	require.ErrorContains(t, "invalid signature format", err)
-}

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

@@ -190,6 +190,9 @@ func TestGetSpec(t *testing.T) {
 	var daap [4]byte
 	copy(daap[:], []byte{'0', '0', '0', '7'})
 	config.DomainAggregateAndProof = daap
+	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
@@ -407,6 +410,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":
@@ -419,8 +424,6 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "0x0a000000", v)
 			case "DOMAIN_APPLICATION_BUILDER":
 				assert.Equal(t, "0x00000001", v)
-			case "DOMAIN_BEACON_BUILDER":
-				assert.Equal(t, "0x1b000000", v)
 			case "DOMAIN_BLOB_SIDECAR":
 				assert.Equal(t, "0x00000000", v)
 			case "TRANSITION_TOTAL_DIFFICULTY":

beacon-chain/state/BUILD.bazel

@@ -5,14 +5,12 @@ go_library(
     srcs = [
         "error.go",
         "interfaces.go",
-        "interfaces_gloas.go",
         "prometheus.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/state",
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/state/state-native/custom-types:go_default_library",
-        "//beacon-chain/state/state-native/types:go_default_library",
         "//config/fieldparams:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",

beacon-chain/state/interfaces.go

@@ -10,7 +10,6 @@ import (
 
 	"github.com/OffchainLabs/go-bitfield"
 	customtypes "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/custom-types"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
@@ -44,8 +43,6 @@ type Prover interface {
 	FinalizedRootProof(ctx context.Context) ([][]byte, error)
 	CurrentSyncCommitteeProof(ctx context.Context) ([][]byte, error)
 	NextSyncCommitteeProof(ctx context.Context) ([][]byte, error)
-
-	ProofByFieldIndex(ctx context.Context, f types.FieldIndex) ([][]byte, error)
 }
 
 // ReadOnlyBeaconState defines a struct which only has read access to beacon state methods.
@@ -66,7 +63,6 @@ type ReadOnlyBeaconState interface {
 	ReadOnlyDeposits
 	ReadOnlyConsolidations
 	ReadOnlyProposerLookahead
-	ReadOnlyGloasFields
 	ToProtoUnsafe() any
 	ToProto() any
 	GenesisTime() time.Time
@@ -103,7 +99,6 @@ type WriteOnlyBeaconState interface {
 	WriteOnlyDeposits
 	WriteOnlyProposerLookahead
 	SetGenesisTime(val time.Time) error
-	WriteOnlyGloasFields
 	SetGenesisValidatorsRoot(val []byte) error
 	SetSlot(val primitives.Slot) error
 	SetFork(val *ethpb.Fork) error

beacon-chain/state/interfaces_gloas.go

@@ -1,26 +0,0 @@
-package state
-
-import (
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-type WriteOnlyGloasFields interface {
-	SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error
-	SetBuilderPendingPayment(index primitives.Slot, payment *ethpb.BuilderPendingPayment) error
-	SetLatestBlockHash(hash [32]byte) error
-	SetExecutionPayloadAvailability(index primitives.Slot, available bool) error
-	SetBuilderPendingPayments(payments []*ethpb.BuilderPendingPayment) error
-	AppendBuilderPendingWithdrawal(withdrawal *ethpb.BuilderPendingWithdrawal) error
-}
-
-type ReadOnlyGloasFields interface {
-	LatestBlockHash() ([32]byte, error)
-	BuilderPendingPayment(slot primitives.Slot) (*ethpb.BuilderPendingPayment, error)
-	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
-	BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error)
-	LatestExecutionPayloadBid() (interfaces.ROExecutionPayloadBid, error)
-	PayloadExpectedWithdrawals() ([]*enginev1.Withdrawal, error)
-}

beacon-chain/state/state-native/BUILD.bazel

@@ -14,7 +14,6 @@ go_library(
         "getters_deposits.go",
         "getters_eth1.go",
         "getters_exit.go",
-        "getters_gloas.go",
         "getters_misc.go",
         "getters_participation.go",
         "getters_payload_header.go",
@@ -37,7 +36,6 @@ go_library(
         "setters_deposit_requests.go",
         "setters_deposits.go",
         "setters_eth1.go",
-        "setters_gloas.go",
         "setters_misc.go",
         "setters_participation.go",
         "setters_payload_header.go",
@@ -99,7 +97,6 @@ go_test(
         "getters_deposit_requests_test.go",
         "getters_deposits_test.go",
         "getters_exit_test.go",
-        "getters_gloas_test.go",
         "getters_participation_test.go",
         "getters_setters_lookahead_test.go",
         "getters_test.go",
@@ -117,7 +114,6 @@ go_test(
         "setters_deposit_requests_test.go",
         "setters_deposits_test.go",
         "setters_eth1_test.go",
-        "setters_gloas_test.go",
         "setters_misc_test.go",
         "setters_participation_test.go",
         "setters_payload_header_test.go",

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

@@ -1,81 +0,0 @@
-package state_native
-
-import (
-	"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"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-// LatestBlockHash returns the hash of the latest execution block.
-func (b *BeaconState) LatestBlockHash() ([32]byte, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.latestBlockHash == nil {
-		return [32]byte{}, nil
-	}
-
-	return [32]byte(b.latestBlockHash), nil
-}
-
-// BuilderPendingPayment returns a specific builder pending payment for the given slot.
-func (b *BeaconState) BuilderPendingPayment(slot primitives.Slot) (*ethpb.BuilderPendingPayment, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
-
-	return ethpb.CopyBuilderPendingPayment(b.builderPendingPayments[paymentIndex]), nil
-}
-
-// BuilderPendingPayments returns the builder pending payments.
-func (b *BeaconState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.builderPendingPayments == nil {
-		return make([]*ethpb.BuilderPendingPayment, 0), nil
-	}
-
-	return ethpb.CopyBuilderPendingPaymentSlice(b.builderPendingPayments), nil
-}
-
-// BuilderPendingWithdrawals returns the builder pending withdrawals.
-func (b *BeaconState) BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.builderPendingWithdrawals == nil {
-		return make([]*ethpb.BuilderPendingWithdrawal, 0), nil
-	}
-
-	return ethpb.CopyBuilderPendingWithdrawalSlice(b.builderPendingWithdrawals), nil
-}
-
-// LatestExecutionPayloadBid returns the cached latest execution payload bid for Gloas.
-func (b *BeaconState) LatestExecutionPayloadBid() (interfaces.ROExecutionPayloadBid, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.latestExecutionPayloadBid == nil {
-		return nil, nil
-	}
-
-	return blocks.WrappedROExecutionPayloadBid(b.latestExecutionPayloadBid.Copy())
-}
-
-// PayloadExpectedWithdrawals returns the expected withdrawals for the current payload.
-func (b *BeaconState) PayloadExpectedWithdrawals() ([]*enginev1.Withdrawal, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.payloadExpectedWithdrawals == nil {
-		return make([]*enginev1.Withdrawal, 0), nil
-	}
-
-	return b.payloadExpectedWithdrawalsVal(), nil
-}

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

@@ -1,67 +0,0 @@
-package state_native_test
-
-import (
-	"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/testing/assert"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func TestLatestBlockHash(t *testing.T) {
-	t.Run("nil hash returns zero", func(t *testing.T) {
-		s, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{})
-		require.NoError(t, err)
-
-		hash, err := s.LatestBlockHash()
-		require.NoError(t, err)
-		assert.Equal(t, [32]byte{}, hash)
-	})
-
-	t.Run("returns value", func(t *testing.T) {
-		var want [32]byte
-		copy(want[:], []byte("latest-block-hash"))
-
-		s, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			LatestBlockHash: want[:],
-		})
-		require.NoError(t, err)
-
-		hash, err := s.LatestBlockHash()
-		require.NoError(t, err)
-		assert.Equal(t, want, hash)
-	})
-}
-
-func TestBuilderPendingPayment(t *testing.T) {
-	t.Run("returns payment for slot", func(t *testing.T) {
-		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-		slot := primitives.Slot(7)
-		paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
-		payments := make([]*ethpb.BuilderPendingPayment, slotsPerEpoch*2)
-		payment := &ethpb.BuilderPendingPayment{
-			Weight: 11,
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20},
-				Amount:       99,
-				BuilderIndex: 3,
-			},
-		}
-		payments[paymentIndex] = payment
-
-		s, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			BuilderPendingPayments: payments,
-		})
-		require.NoError(t, err)
-
-		got, err := s.BuilderPendingPayment(slot)
-		require.NoError(t, err)
-		require.DeepEqual(t, payment, got)
-
-		got.Withdrawal.FeeRecipient[0] = 9
-		require.Equal(t, byte(1), payment.Withdrawal.FeeRecipient[0])
-	})
-}

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

@@ -5,7 +5,6 @@ import (
 	"encoding/binary"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/container/trie"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
@@ -40,51 +39,33 @@ func (b *BeaconState) NextSyncCommitteeGeneralizedIndex() (uint64, error) {
 
 // CurrentSyncCommitteeProof from the state's Merkle trie representation.
 func (b *BeaconState) CurrentSyncCommitteeProof(ctx context.Context) ([][]byte, error) {
-	return b.ProofByFieldIndex(ctx, types.CurrentSyncCommittee)
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	if b.version == version.Phase0 {
+		return nil, errNotSupported("CurrentSyncCommitteeProof", b.version)
+	}
+
+	// In case the Merkle layers of the trie are not populated, we need
+	// to perform some initialization.
+	if err := b.initializeMerkleLayers(ctx); err != nil {
+		return nil, err
+	}
+	// Our beacon state uses a "dirty" fields pattern which requires us to
+	// recompute branches of the Merkle layers that are marked as dirty.
+	if err := b.recomputeDirtyFields(ctx); err != nil {
+		return nil, err
+	}
+	return trie.ProofFromMerkleLayers(b.merkleLayers, types.CurrentSyncCommittee.RealPosition()), nil
 }
 
 // NextSyncCommitteeProof from the state's Merkle trie representation.
 func (b *BeaconState) NextSyncCommitteeProof(ctx context.Context) ([][]byte, error) {
-	return b.ProofByFieldIndex(ctx, types.NextSyncCommittee)
-}
-
-// FinalizedRootProof crafts a Merkle proof for the finalized root
-// contained within the finalized checkpoint of a beacon state.
-func (b *BeaconState) FinalizedRootProof(ctx context.Context) ([][]byte, error) {
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
-	branchProof, err := b.proofByFieldIndex(ctx, types.FinalizedCheckpoint)
-	if err != nil {
-		return nil, err
-	}
-
-	// The epoch field of a finalized checkpoint is the neighbor
-	// index of the finalized root field in its Merkle tree representation
-	// of the checkpoint. This neighbor is the first element added to the proof.
-	epochBuf := make([]byte, 8)
-	binary.LittleEndian.PutUint64(epochBuf, uint64(b.finalizedCheckpointVal().Epoch))
-	epochRoot := bytesutil.ToBytes32(epochBuf)
-	proof := make([][]byte, 0)
-	proof = append(proof, epochRoot[:])
-	proof = append(proof, branchProof...)
-	return proof, nil
-}
-
-// ProofByFieldIndex constructs proofs for given field index with lock acquisition.
-func (b *BeaconState) ProofByFieldIndex(ctx context.Context, f types.FieldIndex) ([][]byte, error) {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	return b.proofByFieldIndex(ctx, f)
-}
-
-// proofByFieldIndex constructs proofs for given field index.
-// Important: it is assumed that beacon state mutex is locked when calling this method.
-func (b *BeaconState) proofByFieldIndex(ctx context.Context, f types.FieldIndex) ([][]byte, error) {
-	err := b.validateFieldIndex(f)
-	if err != nil {
-		return nil, err
+	if b.version == version.Phase0 {
+		return nil, errNotSupported("NextSyncCommitteeProof", b.version)
 	}
 
 	if err := b.initializeMerkleLayers(ctx); err != nil {
@@ -93,40 +74,35 @@ func (b *BeaconState) proofByFieldIndex(ctx context.Context, f types.FieldIndex)
 	if err := b.recomputeDirtyFields(ctx); err != nil {
 		return nil, err
 	}
-	return trie.ProofFromMerkleLayers(b.merkleLayers, f.RealPosition()), nil
+	return trie.ProofFromMerkleLayers(b.merkleLayers, types.NextSyncCommittee.RealPosition()), nil
 }
 
-func (b *BeaconState) validateFieldIndex(f types.FieldIndex) error {
-	switch b.version {
-	case version.Phase0:
-		if f.RealPosition() > params.BeaconConfig().BeaconStateFieldCount-1 {
-			return errNotSupported(f.String(), b.version)
-		}
-	case version.Altair:
-		if f.RealPosition() > params.BeaconConfig().BeaconStateAltairFieldCount-1 {
-			return errNotSupported(f.String(), b.version)
-		}
-	case version.Bellatrix:
-		if f.RealPosition() > params.BeaconConfig().BeaconStateBellatrixFieldCount-1 {
-			return errNotSupported(f.String(), b.version)
-		}
-	case version.Capella:
-		if f.RealPosition() > params.BeaconConfig().BeaconStateCapellaFieldCount-1 {
-			return errNotSupported(f.String(), b.version)
-		}
-	case version.Deneb:
-		if f.RealPosition() > params.BeaconConfig().BeaconStateDenebFieldCount-1 {
-			return errNotSupported(f.String(), b.version)
-		}
-	case version.Electra:
-		if f.RealPosition() > params.BeaconConfig().BeaconStateElectraFieldCount-1 {
-			return errNotSupported(f.String(), b.version)
-		}
-	case version.Fulu:
-		if f.RealPosition() > params.BeaconConfig().BeaconStateFuluFieldCount-1 {
-			return errNotSupported(f.String(), b.version)
-		}
+// FinalizedRootProof crafts a Merkle proof for the finalized root
+// contained within the finalized checkpoint of a beacon state.
+func (b *BeaconState) FinalizedRootProof(ctx context.Context) ([][]byte, error) {
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	if b.version == version.Phase0 {
+		return nil, errNotSupported("FinalizedRootProof", b.version)
 	}
 
-	return nil
+	if err := b.initializeMerkleLayers(ctx); err != nil {
+		return nil, err
+	}
+	if err := b.recomputeDirtyFields(ctx); err != nil {
+		return nil, err
+	}
+	cpt := b.finalizedCheckpointVal()
+	// The epoch field of a finalized checkpoint is the neighbor
+	// index of the finalized root field in its Merkle tree representation
+	// of the checkpoint. This neighbor is the first element added to the proof.
+	epochBuf := make([]byte, 8)
+	binary.LittleEndian.PutUint64(epochBuf, uint64(cpt.Epoch))
+	epochRoot := bytesutil.ToBytes32(epochBuf)
+	proof := make([][]byte, 0)
+	proof = append(proof, epochRoot[:])
+	branch := trie.ProofFromMerkleLayers(b.merkleLayers, types.FinalizedCheckpoint.RealPosition())
+	proof = append(proof, branch...)
+	return proof, nil
 }

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

@@ -21,6 +21,10 @@ func TestBeaconStateMerkleProofs_phase0_notsupported(t *testing.T) {
 		_, err := st.NextSyncCommitteeProof(ctx)
 		require.ErrorContains(t, "not supported", err)
 	})
+	t.Run("finalized root", func(t *testing.T) {
+		_, err := st.FinalizedRootProof(ctx)
+		require.ErrorContains(t, "not supported", err)
+	})
 }
 func TestBeaconStateMerkleProofs_altair(t *testing.T) {
 	ctx := t.Context()

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

@@ -1,101 +0,0 @@
-package state_native
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	parentBlockHash := h.ParentBlockHash()
-	parentBlockRoot := h.ParentBlockRoot()
-	blockHash := h.BlockHash()
-	randao := h.PrevRandao()
-	blobKzgCommitmentsRoot := h.BlobKzgCommitmentsRoot()
-	feeRecipient := h.FeeRecipient()
-	b.latestExecutionPayloadBid = &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        parentBlockHash[:],
-		ParentBlockRoot:        parentBlockRoot[:],
-		BlockHash:              blockHash[:],
-		PrevRandao:             randao[:],
-		GasLimit:               h.GasLimit(),
-		BuilderIndex:           h.BuilderIndex(),
-		Slot:                   h.Slot(),
-		Value:                  h.Value(),
-		ExecutionPayment:       h.ExecutionPayment(),
-		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot[:],
-		FeeRecipient:           feeRecipient[:],
-	}
-	b.markFieldAsDirty(types.LatestExecutionPayloadBid)
-
-	return nil
-}
-
-// SetBuilderPendingPayment sets a builder pending payment for the specified slot.
-func (b *BeaconState) SetBuilderPendingPayment(slot primitives.Slot, payment *ethpb.BuilderPendingPayment) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
-
-	b.builderPendingPayments[paymentIndex] = ethpb.CopyBuilderPendingPayment(payment)
-
-	b.markFieldAsDirty(types.BuilderPendingPayments)
-	return nil
-}
-
-// SetLatestBlockHash sets the latest execution block hash.
-func (b *BeaconState) SetLatestBlockHash(hash [32]byte) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.latestBlockHash = hash[:]
-	b.markFieldAsDirty(types.LatestBlockHash)
-	return nil
-}
-
-// SetExecutionPayloadAvailability sets the execution payload availability bit for a specific slot.
-func (b *BeaconState) SetExecutionPayloadAvailability(index primitives.Slot, available bool) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	bitIndex := index % params.BeaconConfig().SlotsPerHistoricalRoot
-	byteIndex := bitIndex / 8
-	bitPosition := bitIndex % 8
-
-	// Set or clear the bit
-	if available {
-		b.executionPayloadAvailability[byteIndex] |= 1 << bitPosition
-	} else {
-		b.executionPayloadAvailability[byteIndex] &^= 1 << bitPosition
-	}
-
-	b.markFieldAsDirty(types.ExecutionPayloadAvailability)
-	return nil
-}
-
-// SetBuilderPendingPayments sets the entire builder pending payments array.
-func (b *BeaconState) SetBuilderPendingPayments(payments []*ethpb.BuilderPendingPayment) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.builderPendingPayments = ethpb.CopyBuilderPendingPaymentSlice(payments)
-	b.markFieldAsDirty(types.BuilderPendingPayments)
-	return nil
-}
-
-// AppendBuilderPendingWithdrawal appends a builder pending withdrawal to the list.
-func (b *BeaconState) AppendBuilderPendingWithdrawal(withdrawal *ethpb.BuilderPendingWithdrawal) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.builderPendingWithdrawals = append(b.builderPendingWithdrawals, ethpb.CopyBuilderPendingWithdrawal(withdrawal))
-	b.markFieldAsDirty(types.BuilderPendingWithdrawals)
-	return nil
-}

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

@@ -1,121 +0,0 @@
-package state_native
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
-	"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/testing/require"
-)
-
-func TestSetBuilderPendingPayment(t *testing.T) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	slot := primitives.Slot(7)
-	paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
-	payment := &ethpb.BuilderPendingPayment{
-		Weight: 11,
-		Withdrawal: &ethpb.BuilderPendingWithdrawal{
-			FeeRecipient: []byte{1, 2, 3, 4, 5},
-			Amount:       99,
-			BuilderIndex: 3,
-		},
-	}
-
-	state := &BeaconState{
-		builderPendingPayments: make([]*ethpb.BuilderPendingPayment, slotsPerEpoch*2),
-		dirtyFields:            make(map[types.FieldIndex]bool),
-	}
-
-	require.NoError(t, state.SetBuilderPendingPayment(slot, payment))
-	require.Equal(t, true, state.dirtyFields[types.BuilderPendingPayments])
-	require.DeepEqual(t, payment, state.builderPendingPayments[paymentIndex])
-
-	state.builderPendingPayments[paymentIndex].Withdrawal.FeeRecipient[0] = 9
-	require.Equal(t, byte(1), payment.Withdrawal.FeeRecipient[0])
-}
-
-func TestSetLatestBlockHash(t *testing.T) {
-	var hash [32]byte
-	copy(hash[:], []byte("latest-block-hash"))
-
-	state := &BeaconState{
-		dirtyFields: make(map[types.FieldIndex]bool),
-	}
-
-	require.NoError(t, state.SetLatestBlockHash(hash))
-	require.Equal(t, true, state.dirtyFields[types.LatestBlockHash])
-	require.DeepEqual(t, hash[:], state.latestBlockHash)
-}
-
-func TestSetExecutionPayloadAvailability(t *testing.T) {
-	state := &BeaconState{
-		executionPayloadAvailability: make([]byte, params.BeaconConfig().SlotsPerHistoricalRoot/8),
-		dirtyFields:                  make(map[types.FieldIndex]bool),
-	}
-
-	slot := primitives.Slot(10)
-	bitIndex := slot % params.BeaconConfig().SlotsPerHistoricalRoot
-	byteIndex := bitIndex / 8
-	bitPosition := bitIndex % 8
-
-	require.NoError(t, state.SetExecutionPayloadAvailability(slot, true))
-	require.Equal(t, true, state.dirtyFields[types.ExecutionPayloadAvailability])
-	require.Equal(t, byte(1<<bitPosition), state.executionPayloadAvailability[byteIndex]&(1<<bitPosition))
-
-	require.NoError(t, state.SetExecutionPayloadAvailability(slot, false))
-	require.Equal(t, byte(0), state.executionPayloadAvailability[byteIndex]&(1<<bitPosition))
-}
-
-func TestSetBuilderPendingPayments(t *testing.T) {
-	payments := []*ethpb.BuilderPendingPayment{
-		{
-			Weight: 1,
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: []byte{1, 1, 1},
-				Amount:       5,
-				BuilderIndex: 2,
-			},
-		},
-		{
-			Weight: 2,
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: []byte{2, 2, 2},
-				Amount:       6,
-				BuilderIndex: 4,
-			},
-		},
-	}
-
-	state := &BeaconState{
-		dirtyFields: make(map[types.FieldIndex]bool),
-	}
-
-	require.NoError(t, state.SetBuilderPendingPayments(payments))
-	require.Equal(t, true, state.dirtyFields[types.BuilderPendingPayments])
-	require.DeepEqual(t, payments, state.builderPendingPayments)
-
-	state.builderPendingPayments[0].Weight = 99
-	require.Equal(t, primitives.Gwei(1), payments[0].Weight)
-}
-
-func TestAppendBuilderPendingWithdrawal(t *testing.T) {
-	withdrawal := &ethpb.BuilderPendingWithdrawal{
-		FeeRecipient: []byte{9, 8, 7},
-		Amount:       77,
-		BuilderIndex: 12,
-	}
-
-	state := &BeaconState{
-		dirtyFields: make(map[types.FieldIndex]bool),
-	}
-
-	require.NoError(t, state.AppendBuilderPendingWithdrawal(withdrawal))
-	require.Equal(t, true, state.dirtyFields[types.BuilderPendingWithdrawals])
-	require.Equal(t, 1, len(state.builderPendingWithdrawals))
-	require.DeepEqual(t, withdrawal, state.builderPendingWithdrawals[0])
-
-	state.builderPendingWithdrawals[0].FeeRecipient[0] = 1
-	require.Equal(t, byte(9), withdrawal.FeeRecipient[0])
-}

changelog/syjn99_generalize-proof-generation.md

@@ -1,3 +0,0 @@
-### Added
-
-- Add `ProofByFieldIndex` to generalize merkle proof generation for `BeaconState`.

changelog/t_gloas-process-execution-payload.md

@@ -1,3 +0,0 @@
-### Added
-
-- Add process execution payload for gloas

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

@@ -139,7 +139,7 @@ type BeaconChainConfig struct {
 	DomainApplicationMask             [4]byte `yaml:"DOMAIN_APPLICATION_MASK" spec:"true"`               // DomainApplicationMask defines the BLS signature domain for application mask.
 	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

@@ -182,7 +182,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	DomainApplicationMask:             bytesutil.Uint32ToBytes4(0x00000001),
 	DomainApplicationBuilder:          bytesutil.Uint32ToBytes4(0x00000001),
 	DomainBLSToExecutionChange:        bytesutil.Uint32ToBytes4(0x0A000000),
-	DomainBeaconBuilder:               bytesutil.Uint32ToBytes4(0x1B000000),
+	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/blocks/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "execution.go",
-        "execution_payload_envelope.go",
         "factory.go",
         "get_payload.go",
         "getters.go",
@@ -15,13 +14,11 @@ go_library(
         "roblock.go",
         "rodatacolumn.go",
         "setters.go",
-        "signed_execution_bid.go",
         "types.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/consensus-types/blocks",
     visibility = ["//visibility:public"],
     deps = [
-        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -37,7 +34,6 @@ go_library(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/validator-client:go_default_library",
         "//runtime/version:go_default_library",
-        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_prysmaticlabs_gohashtree//:go_default_library",
@@ -48,7 +44,6 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
-        "execution_payload_envelope_test.go",
         "execution_test.go",
         "factory_test.go",
         "getters_test.go",
@@ -62,7 +57,6 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//beacon-chain/core/signing:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types:go_default_library",

consensus-types/blocks/execution_payload_envelope.go

@@ -1,156 +0,0 @@
-package blocks
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	field_params "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	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/encoding/ssz"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/ethereum/go-ethereum/common"
-	"google.golang.org/protobuf/proto"
-)
-
-type signedExecutionPayloadEnvelope struct {
-	s *ethpb.SignedExecutionPayloadEnvelope
-}
-
-type executionPayloadEnvelope struct {
-	p *ethpb.ExecutionPayloadEnvelope
-}
-
-// WrappedROSignedExecutionPayloadEnvelope wraps a signed execution payload envelope proto in a read-only interface.
-func WrappedROSignedExecutionPayloadEnvelope(s *ethpb.SignedExecutionPayloadEnvelope) (interfaces.ROSignedExecutionPayloadEnvelope, error) {
-	w := signedExecutionPayloadEnvelope{s: s}
-	if w.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return w, nil
-}
-
-// WrappedROExecutionPayloadEnvelope wraps an execution payload envelope proto in a read-only interface.
-func WrappedROExecutionPayloadEnvelope(p *ethpb.ExecutionPayloadEnvelope) (interfaces.ROExecutionPayloadEnvelope, error) {
-	w := &executionPayloadEnvelope{p: p}
-	if w.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return w, nil
-}
-
-// Envelope returns the execution payload envelope as a read-only interface.
-func (s signedExecutionPayloadEnvelope) Envelope() (interfaces.ROExecutionPayloadEnvelope, error) {
-	return WrappedROExecutionPayloadEnvelope(s.s.Message)
-}
-
-// Signature returns the BLS signature as a 96-byte array.
-func (s signedExecutionPayloadEnvelope) Signature() [field_params.BLSSignatureLength]byte {
-	return [field_params.BLSSignatureLength]byte(s.s.Signature)
-}
-
-// IsNil reports whether the signed envelope or its contents are invalid.
-func (s signedExecutionPayloadEnvelope) IsNil() bool {
-	if s.s == nil {
-		return true
-	}
-	if len(s.s.Signature) != field_params.BLSSignatureLength {
-		return true
-	}
-	w := executionPayloadEnvelope{p: s.s.Message}
-	return w.IsNil()
-}
-
-// SigningRoot computes the signing root for the signed envelope with the provided domain.
-func (s signedExecutionPayloadEnvelope) SigningRoot(domain []byte) (root [32]byte, err error) {
-	return signing.ComputeSigningRoot(s.s.Message, domain)
-}
-
-// Proto returns the underlying protobuf message.
-func (s signedExecutionPayloadEnvelope) Proto() proto.Message {
-	return s.s
-}
-
-// IsNil reports whether the envelope or its required fields are invalid.
-func (p *executionPayloadEnvelope) IsNil() bool {
-	if p.p == nil {
-		return true
-	}
-	if p.p.Payload == nil {
-		return true
-	}
-	if len(p.p.BeaconBlockRoot) != field_params.RootLength {
-		return true
-	}
-	if p.p.BlobKzgCommitments == nil {
-		return true
-	}
-	return false
-}
-
-// IsBlinded reports whether the envelope contains a blinded payload.
-func (p *executionPayloadEnvelope) IsBlinded() bool {
-	return !p.IsNil() && p.p.Payload == nil
-}
-
-// Execution returns the execution payload as a read-only interface.
-func (p *executionPayloadEnvelope) Execution() (interfaces.ExecutionData, error) {
-	if p.IsBlinded() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return WrappedExecutionPayloadDeneb(p.p.Payload)
-}
-
-// ExecutionRequests returns the execution requests attached to the envelope.
-func (p *executionPayloadEnvelope) ExecutionRequests() *enginev1.ExecutionRequests {
-	return p.p.ExecutionRequests
-}
-
-// BuilderIndex returns the proposer/builder index for the envelope.
-func (p *executionPayloadEnvelope) BuilderIndex() primitives.BuilderIndex {
-	return p.p.BuilderIndex
-}
-
-// BeaconBlockRoot returns the beacon block root referenced by the envelope.
-func (p *executionPayloadEnvelope) BeaconBlockRoot() [field_params.RootLength]byte {
-	return [field_params.RootLength]byte(p.p.BeaconBlockRoot)
-}
-
-// BlobKzgCommitments returns a copy of the envelope's KZG commitments.
-func (p *executionPayloadEnvelope) BlobKzgCommitments() [][]byte {
-	commitments := make([][]byte, len(p.p.BlobKzgCommitments))
-	for i, commit := range p.p.BlobKzgCommitments {
-		commitments[i] = make([]byte, len(commit))
-		copy(commitments[i], commit)
-	}
-	return commitments
-}
-
-// VersionedHashes returns versioned hashes derived from the KZG commitments.
-func (p *executionPayloadEnvelope) VersionedHashes() []common.Hash {
-	commitments := p.p.BlobKzgCommitments
-	versionedHashes := make([]common.Hash, len(commitments))
-	for i, commitment := range commitments {
-		versionedHashes[i] = primitives.ConvertKzgCommitmentToVersionedHash(commitment)
-	}
-	return versionedHashes
-}
-
-// BlobKzgCommitmentsRoot returns the SSZ root of the envelope's KZG commitments.
-func (p *executionPayloadEnvelope) BlobKzgCommitmentsRoot() ([field_params.RootLength]byte, error) {
-	if p.IsNil() || p.p.BlobKzgCommitments == nil {
-		return [field_params.RootLength]byte{}, consensus_types.ErrNilObjectWrapped
-	}
-
-	return ssz.KzgCommitmentsRoot(p.p.BlobKzgCommitments)
-}
-
-// Slot returns the slot of the envelope.
-func (p *executionPayloadEnvelope) Slot() primitives.Slot {
-	return p.p.Slot
-}
-
-// StateRoot returns the state root carried by the envelope.
-func (p *executionPayloadEnvelope) StateRoot() [field_params.RootLength]byte {
-	return [field_params.RootLength]byte(p.p.StateRoot)
-}

consensus-types/blocks/execution_payload_envelope_test.go

@@ -1,115 +0,0 @@
-package blocks_test
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/assert"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func validExecutionPayloadEnvelope() *ethpb.ExecutionPayloadEnvelope {
-	payload := &enginev1.ExecutionPayloadDeneb{
-		ParentHash:    bytes.Repeat([]byte{0x01}, 32),
-		FeeRecipient:  bytes.Repeat([]byte{0x02}, 20),
-		StateRoot:     bytes.Repeat([]byte{0x03}, 32),
-		ReceiptsRoot:  bytes.Repeat([]byte{0x04}, 32),
-		LogsBloom:     bytes.Repeat([]byte{0x05}, 256),
-		PrevRandao:    bytes.Repeat([]byte{0x06}, 32),
-		BlockNumber:   1,
-		GasLimit:      2,
-		GasUsed:       3,
-		Timestamp:     4,
-		BaseFeePerGas: bytes.Repeat([]byte{0x07}, 32),
-		BlockHash:     bytes.Repeat([]byte{0x08}, 32),
-		Transactions:  [][]byte{},
-		Withdrawals:   []*enginev1.Withdrawal{},
-		BlobGasUsed:   0,
-		ExcessBlobGas: 0,
-	}
-
-	return &ethpb.ExecutionPayloadEnvelope{
-		Payload:            payload,
-		ExecutionRequests:  &enginev1.ExecutionRequests{},
-		BuilderIndex:       10,
-		BeaconBlockRoot:    bytes.Repeat([]byte{0xAA}, 32),
-		Slot:               9,
-		BlobKzgCommitments: [][]byte{bytes.Repeat([]byte{0x0C}, 48)},
-		StateRoot:          bytes.Repeat([]byte{0xBB}, 32),
-	}
-}
-
-func TestWrappedROExecutionPayloadEnvelope(t *testing.T) {
-	t.Run("returns error on invalid beacon root length", func(t *testing.T) {
-		invalid := validExecutionPayloadEnvelope()
-		invalid.BeaconBlockRoot = []byte{0x01}
-		_, err := blocks.WrappedROExecutionPayloadEnvelope(invalid)
-		require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
-	})
-
-	t.Run("wraps and exposes fields", func(t *testing.T) {
-		env := validExecutionPayloadEnvelope()
-		wrapped, err := blocks.WrappedROExecutionPayloadEnvelope(env)
-		require.NoError(t, err)
-
-		require.Equal(t, primitives.BuilderIndex(10), wrapped.BuilderIndex())
-		require.Equal(t, primitives.Slot(9), wrapped.Slot())
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xAA}, 32)), wrapped.BeaconBlockRoot())
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xBB}, 32)), wrapped.StateRoot())
-
-		commitments := wrapped.BlobKzgCommitments()
-		assert.DeepEqual(t, env.BlobKzgCommitments, commitments)
-
-		versioned := wrapped.VersionedHashes()
-		require.Equal(t, 1, len(versioned))
-
-		reqs := wrapped.ExecutionRequests()
-		require.NotNil(t, reqs)
-
-		exec, err := wrapped.Execution()
-		require.NoError(t, err)
-		assert.DeepEqual(t, env.Payload.ParentHash, exec.ParentHash())
-	})
-}
-
-func TestWrappedROSignedExecutionPayloadEnvelope(t *testing.T) {
-	t.Run("returns error for invalid signature length", func(t *testing.T) {
-		signed := &ethpb.SignedExecutionPayloadEnvelope{
-			Message:   validExecutionPayloadEnvelope(),
-			Signature: bytes.Repeat([]byte{0xAA}, 95),
-		}
-		_, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signed)
-		require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
-	})
-
-	t.Run("wraps and provides envelope/signing data", func(t *testing.T) {
-		sig := bytes.Repeat([]byte{0xAB}, 96)
-		signed := &ethpb.SignedExecutionPayloadEnvelope{
-			Message:   validExecutionPayloadEnvelope(),
-			Signature: sig,
-		}
-
-		wrapped, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signed)
-		require.NoError(t, err)
-
-		gotSig := wrapped.Signature()
-		assert.DeepEqual(t, [96]byte(sig), gotSig)
-
-		env, err := wrapped.Envelope()
-		require.NoError(t, err)
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xAA}, 32)), env.BeaconBlockRoot())
-
-		domain := bytes.Repeat([]byte{0xCC}, 32)
-		wantRoot, err := signing.ComputeSigningRoot(signed.Message, domain)
-		require.NoError(t, err)
-		gotRoot, err := wrapped.SigningRoot(domain)
-		require.NoError(t, err)
-		require.Equal(t, wantRoot, gotRoot)
-	})
-}

consensus-types/blocks/signed_execution_bid.go

@@ -1,140 +0,0 @@
-package blocks
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	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"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-// signedExecutionPayloadBid wraps the protobuf signed execution payload bid
-// and implements the ROSignedExecutionPayloadBid interface.
-type signedExecutionPayloadBid struct {
-	bid *ethpb.SignedExecutionPayloadBid
-}
-
-// executionPayloadBidGloas wraps the protobuf execution payload bid for Gloas fork
-// and implements the ROExecutionPayloadBidGloas interface.
-type executionPayloadBidGloas struct {
-	payload *ethpb.ExecutionPayloadBid
-}
-
-// IsNil checks if the signed execution payload bid is nil or invalid.
-func (s signedExecutionPayloadBid) IsNil() bool {
-	if s.bid == nil {
-		return true
-	}
-
-	if _, err := WrappedROExecutionPayloadBid(s.bid.Message); err != nil {
-		return true
-	}
-
-	return len(s.bid.Signature) != 96
-}
-
-// IsNil checks if the execution payload bid is nil or has invalid fields.
-func (h executionPayloadBidGloas) IsNil() bool {
-	if h.payload == nil {
-		return true
-	}
-
-	if len(h.payload.ParentBlockHash) != 32 ||
-		len(h.payload.ParentBlockRoot) != 32 ||
-		len(h.payload.BlockHash) != 32 ||
-		len(h.payload.BlobKzgCommitmentsRoot) != 32 {
-		return true
-	}
-
-	return false
-}
-
-// WrappedROSignedExecutionPayloadBid creates a new read-only signed execution payload bid
-// wrapper from the given protobuf message.
-func WrappedROSignedExecutionPayloadBid(pb *ethpb.SignedExecutionPayloadBid) (interfaces.ROSignedExecutionPayloadBid, error) {
-	wrapper := signedExecutionPayloadBid{bid: pb}
-	if wrapper.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return wrapper, nil
-}
-
-// WrappedROExecutionPayloadBid creates a new read-only execution payload bid
-// wrapper for the Gloas fork from the given protobuf message.
-func WrappedROExecutionPayloadBid(pb *ethpb.ExecutionPayloadBid) (interfaces.ROExecutionPayloadBid, error) {
-	wrapper := executionPayloadBidGloas{payload: pb}
-	if wrapper.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return wrapper, nil
-}
-
-// Bid returns the execution payload bid as a read-only interface.
-func (s signedExecutionPayloadBid) Bid() (interfaces.ROExecutionPayloadBid, error) {
-	return WrappedROExecutionPayloadBid(s.bid.Message)
-}
-
-// SigningRoot computes the signing root for the execution payload bid with the given domain.
-func (s signedExecutionPayloadBid) SigningRoot(domain []byte) ([32]byte, error) {
-	return signing.ComputeSigningRoot(s.bid.Message, domain)
-}
-
-// Signature returns the BLS signature as a 96-byte array.
-func (s signedExecutionPayloadBid) Signature() [96]byte {
-	return [96]byte(s.bid.Signature)
-}
-
-// ParentBlockHash returns the hash of the parent execution block.
-func (h executionPayloadBidGloas) ParentBlockHash() [32]byte {
-	return [32]byte(h.payload.ParentBlockHash)
-}
-
-// ParentBlockRoot returns the beacon block root of the parent block.
-func (h executionPayloadBidGloas) ParentBlockRoot() [32]byte {
-	return [32]byte(h.payload.ParentBlockRoot)
-}
-
-// PrevRandao returns the previous randao value for the execution block.
-func (h executionPayloadBidGloas) PrevRandao() [32]byte {
-	return [32]byte(h.payload.PrevRandao)
-}
-
-// BlockHash returns the hash of the execution block.
-func (h executionPayloadBidGloas) BlockHash() [32]byte {
-	return [32]byte(h.payload.BlockHash)
-}
-
-// GasLimit returns the gas limit for the execution block.
-func (h executionPayloadBidGloas) GasLimit() uint64 {
-	return h.payload.GasLimit
-}
-
-// BuilderIndex returns the builder index of the builder who created this bid.
-func (h executionPayloadBidGloas) BuilderIndex() primitives.BuilderIndex {
-	return h.payload.BuilderIndex
-}
-
-// Slot returns the beacon chain slot for which this bid was created.
-func (h executionPayloadBidGloas) Slot() primitives.Slot {
-	return h.payload.Slot
-}
-
-// Value returns the payment value offered by the builder in Gwei.
-func (h executionPayloadBidGloas) Value() primitives.Gwei {
-	return primitives.Gwei(h.payload.Value)
-}
-
-// ExecutionPayment returns the execution payment offered by the builder.
-func (h executionPayloadBidGloas) ExecutionPayment() primitives.Gwei {
-	return primitives.Gwei(h.payload.ExecutionPayment)
-}
-
-// BlobKzgCommitmentsRoot returns the root of the KZG commitments for blobs.
-func (h executionPayloadBidGloas) BlobKzgCommitmentsRoot() [32]byte {
-	return [32]byte(h.payload.BlobKzgCommitmentsRoot)
-}
-
-// FeeRecipient returns the execution address that will receive the builder payment.
-func (h executionPayloadBidGloas) FeeRecipient() [20]byte {
-	return [20]byte(h.payload.FeeRecipient)
-}

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
+}

consensus-types/interfaces/BUILD.bazel

@@ -5,9 +5,7 @@ go_library(
     srcs = [
         "beacon_block.go",
         "error.go",
-        "execution_payload_envelope.go",
         "light_client.go",
-        "signed_execution_payload_bid.go",
         "utils.go",
         "validator.go",
     ],
@@ -20,7 +18,6 @@ go_library(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/validator-client:go_default_library",
         "//runtime/version:go_default_library",
-        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",

consensus-types/interfaces/execution_payload_envelope.go

@@ -1,31 +0,0 @@
-package interfaces
-
-import (
-	field_params "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	"github.com/ethereum/go-ethereum/common"
-	"google.golang.org/protobuf/proto"
-)
-
-type ROSignedExecutionPayloadEnvelope interface {
-	Envelope() (ROExecutionPayloadEnvelope, error)
-	Signature() [field_params.BLSSignatureLength]byte
-	SigningRoot([]byte) ([32]byte, error)
-	IsNil() bool
-	Proto() proto.Message
-}
-
-type ROExecutionPayloadEnvelope interface {
-	Execution() (ExecutionData, error)
-	ExecutionRequests() *enginev1.ExecutionRequests
-	BuilderIndex() primitives.BuilderIndex
-	BeaconBlockRoot() [field_params.RootLength]byte
-	BlobKzgCommitments() [][]byte
-	BlobKzgCommitmentsRoot() ([field_params.RootLength]byte, error)
-	VersionedHashes() []common.Hash
-	Slot() primitives.Slot
-	StateRoot() [field_params.RootLength]byte
-	IsBlinded() bool
-	IsNil() bool
-}

consensus-types/interfaces/signed_execution_payload_bid.go

@@ -1,28 +0,0 @@
-package interfaces
-
-import (
-	field_params "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-)
-
-type ROSignedExecutionPayloadBid interface {
-	Bid() (ROExecutionPayloadBid, error)
-	Signature() [field_params.BLSSignatureLength]byte
-	SigningRoot([]byte) ([32]byte, error)
-	IsNil() bool
-}
-
-type ROExecutionPayloadBid interface {
-	ParentBlockHash() [32]byte
-	ParentBlockRoot() [32]byte
-	PrevRandao() [32]byte
-	BlockHash() [32]byte
-	GasLimit() uint64
-	BuilderIndex() primitives.BuilderIndex
-	Slot() primitives.Slot
-	Value() primitives.Gwei
-	ExecutionPayment() primitives.Gwei
-	BlobKzgCommitmentsRoot() [32]byte
-	FeeRecipient() [20]byte
-	IsNil() bool
-}

encoding/ssz/htrutils.go

@@ -5,7 +5,6 @@ import (
 	"encoding/binary"
 
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/crypto/hash/htr"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
@@ -142,24 +141,3 @@ func withdrawalRoot(w *enginev1.Withdrawal) ([32]byte, error) {
 	}
 	return w.HashTreeRoot()
 }
-
-// KzgCommitmentsRoot computes the HTR for a list of KZG commitments
-func KzgCommitmentsRoot(commitments [][]byte) ([32]byte, error) {
-	roots := make([][32]byte, len(commitments))
-	for i, commitment := range commitments {
-		chunks, err := PackByChunk([][]byte{commitment})
-		if err != nil {
-			return [32]byte{}, err
-		}
-		roots[i] = htr.VectorizedSha256(chunks)[0]
-	}
-
-	commitmentsRoot, err := BitwiseMerkleize(roots, uint64(len(roots)), fieldparams.MaxBlobCommitmentsPerBlock)
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not compute merkleization")
-	}
-
-	length := make([]byte, 32)
-	binary.LittleEndian.PutUint64(length[:8], uint64(len(roots)))
-	return MixInLength(commitmentsRoot, length), nil
-}

proto/prysm/v1alpha1/cloners.go

@@ -189,54 +189,3 @@ func copyBeaconBlockBodyGloas(body *BeaconBlockBodyGloas) *BeaconBlockBodyGloas
 
 	return copied
 }
-
-// CopyBuilderPendingPaymentSlice creates a deep copy of a builder pending payment slice.
-func CopyBuilderPendingPaymentSlice(original []*BuilderPendingPayment) []*BuilderPendingPayment {
-	if original == nil {
-		return nil
-	}
-
-	copied := make([]*BuilderPendingPayment, len(original))
-	for i, payment := range original {
-		copied[i] = CopyBuilderPendingPayment(payment)
-	}
-	return copied
-}
-
-// CopyBuilderPendingPayment creates a deep copy of a builder pending payment.
-func CopyBuilderPendingPayment(original *BuilderPendingPayment) *BuilderPendingPayment {
-	if original == nil {
-		return nil
-	}
-
-	return &BuilderPendingPayment{
-		Weight:     original.Weight,
-		Withdrawal: CopyBuilderPendingWithdrawal(original.Withdrawal),
-	}
-}
-
-// CopyBuilderPendingWithdrawalSlice creates a deep copy of a builder pending withdrawal slice.
-func CopyBuilderPendingWithdrawalSlice(original []*BuilderPendingWithdrawal) []*BuilderPendingWithdrawal {
-	if original == nil {
-		return nil
-	}
-
-	copied := make([]*BuilderPendingWithdrawal, len(original))
-	for i, withdrawal := range original {
-		copied[i] = CopyBuilderPendingWithdrawal(withdrawal)
-	}
-	return copied
-}
-
-// CopyBuilderPendingWithdrawal creates a deep copy of a builder pending withdrawal.
-func CopyBuilderPendingWithdrawal(original *BuilderPendingWithdrawal) *BuilderPendingWithdrawal {
-	if original == nil {
-		return nil
-	}
-
-	return &BuilderPendingWithdrawal{
-		FeeRecipient: bytesutil.SafeCopyBytes(original.FeeRecipient),
-		Amount:       original.Amount,
-		BuilderIndex: original.BuilderIndex,
-	}
-}

proto/prysm/v1alpha1/cloners_test.go

@@ -1246,89 +1246,3 @@ func genPayloadAttestations(num int) []*v1alpha1.PayloadAttestation {
 	}
 	return pas
 }
-
-func TestCopyBuilderPendingWithdrawal(t *testing.T) {
-	t.Run("nil returns nil", func(t *testing.T) {
-		if got := v1alpha1.CopyBuilderPendingWithdrawal(nil); got != nil {
-			t.Fatalf("CopyBuilderPendingWithdrawal(nil) = %v, want nil", got)
-		}
-	})
-
-	t.Run("deep copy", func(t *testing.T) {
-		original := &v1alpha1.BuilderPendingWithdrawal{
-			FeeRecipient: []byte{0x01, 0x02},
-			Amount:       primitives.Gwei(10),
-			BuilderIndex: primitives.BuilderIndex(3),
-		}
-
-		copied := v1alpha1.CopyBuilderPendingWithdrawal(original)
-		if copied == original {
-			t.Fatalf("expected new pointer for withdrawal copy")
-		}
-		if !reflect.DeepEqual(copied, original) {
-			t.Fatalf("CopyBuilderPendingWithdrawal() = %v, want %v", copied, original)
-		}
-
-		original.FeeRecipient[0] = 0xFF
-		original.Amount = primitives.Gwei(20)
-		original.BuilderIndex = primitives.BuilderIndex(9)
-
-		if copied.FeeRecipient[0] == original.FeeRecipient[0] {
-			t.Fatalf("fee recipient was not deep copied")
-		}
-		if copied.Amount != primitives.Gwei(10) {
-			t.Fatalf("amount mutated on copy: %d", copied.Amount)
-		}
-		if copied.BuilderIndex != primitives.BuilderIndex(3) {
-			t.Fatalf("builder index mutated on copy: %d", copied.BuilderIndex)
-		}
-	})
-}
-
-func TestCopyBuilderPendingPayment(t *testing.T) {
-	t.Run("nil returns nil", func(t *testing.T) {
-		if got := v1alpha1.CopyBuilderPendingPayment(nil); got != nil {
-			t.Fatalf("CopyBuilderPendingPayment(nil) = %v, want nil", got)
-		}
-	})
-
-	t.Run("deep copy", func(t *testing.T) {
-		original := &v1alpha1.BuilderPendingPayment{
-			Weight: primitives.Gwei(5),
-			Withdrawal: &v1alpha1.BuilderPendingWithdrawal{
-				FeeRecipient: []byte{0x0A, 0x0B},
-				Amount:       primitives.Gwei(50),
-				BuilderIndex: primitives.BuilderIndex(7),
-			},
-		}
-
-		copied := v1alpha1.CopyBuilderPendingPayment(original)
-		if copied == original {
-			t.Fatalf("expected new pointer for payment copy")
-		}
-		if copied.Withdrawal == original.Withdrawal {
-			t.Fatalf("expected nested withdrawal to be deep copied")
-		}
-		if !reflect.DeepEqual(copied, original) {
-			t.Fatalf("CopyBuilderPendingPayment() = %v, want %v", copied, original)
-		}
-
-		original.Weight = primitives.Gwei(10)
-		original.Withdrawal.FeeRecipient[0] = 0xFF
-		original.Withdrawal.Amount = primitives.Gwei(75)
-		original.Withdrawal.BuilderIndex = primitives.BuilderIndex(9)
-
-		if copied.Weight != primitives.Gwei(5) {
-			t.Fatalf("weight mutated on copy: %d", copied.Weight)
-		}
-		if copied.Withdrawal.FeeRecipient[0] == original.Withdrawal.FeeRecipient[0] {
-			t.Fatalf("withdrawal fee recipient was not deep copied")
-		}
-		if copied.Withdrawal.Amount != primitives.Gwei(50) {
-			t.Fatalf("withdrawal amount mutated on copy: %d", copied.Withdrawal.Amount)
-		}
-		if copied.Withdrawal.BuilderIndex != primitives.BuilderIndex(7) {
-			t.Fatalf("withdrawal builder index mutated on copy: %d", copied.Withdrawal.BuilderIndex)
-		}
-	})
-}

testing/spectest/mainnet/BUILD.bazel

@@ -200,7 +200,7 @@ go_test(
         "fulu__sanity__blocks_test.go",
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
-        "gloas__operations__execution_payload_test.go",
+        "gloas__operations__payload_attestation_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",
         "phase0__epoch_processing__epoch_processing_test.go",

testing/spectest/mainnet/gloas__operations__execution_payload_test.go

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

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

@@ -206,6 +206,7 @@ go_test(
         "fulu__sanity__blocks_test.go",
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
+        "gloas__operations__payload_attestation_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",
         "phase0__epoch_processing__epoch_processing_test.go",
@@ -288,6 +289,7 @@ go_test(
         "//testing/spectest/shared/fulu/rewards:go_default_library",
         "//testing/spectest/shared/fulu/sanity:go_default_library",
         "//testing/spectest/shared/fulu/ssz_static:go_default_library",
+        "//testing/spectest/shared/gloas/operations:go_default_library",
         "//testing/spectest/shared/gloas/ssz_static:go_default_library",
         "//testing/spectest/shared/phase0/epoch_processing:go_default_library",
         "//testing/spectest/shared/phase0/finality:go_default_library",

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

@@ -12,6 +12,7 @@ go_library(
         "deposit.go",
         "deposit_request.go",
         "execution_payload.go",
+        "payload_attestation.go",
         "proposer_slashing.go",
         "slashing.go",
         "sync_aggregate.go",
@@ -26,6 +27,7 @@ go_library(
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/electra:go_default_library",
+        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/state:go_default_library",

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

@@ -4,26 +4,16 @@ go_library(
     name = "go_default_library",
     testonly = True,
     srcs = [
-        "execution_payload.go",
         "helpers.go",
+        "payload_attestation.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations",
     visibility = ["//visibility:public"],
     deps = [
-        "//beacon-chain/core/gloas:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/spectest/utils:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_golang_snappy//:go_default_library",
-        "@com_github_google_go_cmp//cmp:go_default_library",
-        "@io_bazel_rules_go//go/tools/bazel:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-        "@org_golang_google_protobuf//testing/protocmp:go_default_library",
+        "//runtime/version:go_default_library",
+        "//testing/spectest/shared/common/operations:go_default_library",
     ],
 )

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

@@ -1,119 +0,0 @@
-package operations
-
-import (
-	"context"
-	"os"
-	"path"
-	"strings"
-	"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"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	ethpb "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/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/golang/snappy"
-	"github.com/google/go-cmp/cmp"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/testing/protocmp"
-)
-
-type ExecutionConfig struct {
-	Valid bool `json:"execution_valid"`
-}
-
-func sszToSignedExecutionPayloadEnvelope(b []byte) (interfaces.ROSignedExecutionPayloadEnvelope, error) {
-	envelope := &ethpb.SignedExecutionPayloadEnvelope{}
-	if err := envelope.UnmarshalSSZ(b); err != nil {
-		return nil, err
-	}
-	return blocks.WrappedROSignedExecutionPayloadEnvelope(envelope)
-}
-
-func RunExecutionPayloadTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "gloas", "operations/execution_payload/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "gloas", "operations/execution_payload/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			helpers.ClearCache()
-
-			// Check if signed_envelope.ssz_snappy exists, skip if not
-			_, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "signed_envelope.ssz_snappy"))
-			if err != nil && strings.Contains(err.Error(), "could not locate file") {
-				t.Skipf("Skipping test %s: signed_envelope.ssz_snappy not found", folder.Name())
-				return
-			}
-
-			// Read the signed execution payload envelope
-			envelopeFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "signed_envelope.ssz_snappy")
-			require.NoError(t, err)
-			envelopeSSZ, err := snappy.Decode(nil /* dst */, envelopeFile)
-			require.NoError(t, err, "Failed to decompress envelope")
-			signedEnvelope, err := sszToSignedExecutionPayloadEnvelope(envelopeSSZ)
-			require.NoError(t, err, "Failed to unmarshal signed envelope")
-
-			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
-			require.NoError(t, err)
-			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
-			require.NoError(t, err, "Failed to decompress")
-			preBeaconState, err := sszToState(preBeaconStateSSZ)
-			require.NoError(t, err)
-
-			postSSZFilepath, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "post.ssz_snappy"))
-			postSSZExists := true
-			if err != nil && strings.Contains(err.Error(), "could not locate file") {
-				postSSZExists = false
-			} else {
-				require.NoError(t, err)
-			}
-
-			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "execution.yaml")
-			require.NoError(t, err)
-			config := &ExecutionConfig{}
-			require.NoError(t, utils.UnmarshalYaml(file, config), "Failed to Unmarshal")
-			if !config.Valid {
-				t.Skip("Skipping invalid execution engine test as it's never supported")
-			}
-
-			err = gloas.ProcessExecutionPayload(context.Background(), preBeaconState, signedEnvelope)
-			if postSSZExists {
-				require.NoError(t, err)
-				comparePostState(t, postSSZFilepath, preBeaconState)
-			} else if config.Valid {
-				// Note: This doesn't test anything worthwhile. It essentially tests
-				// that *any* error has occurred, not any specific error.
-				if err == nil {
-					t.Fatal("Did not fail when expected")
-				}
-				t.Logf("Expected failure; failure reason = %v", err)
-				return
-			}
-		})
-	}
-}
-
-func comparePostState(t *testing.T, postSSZFilepath string, want state.BeaconState) {
-	postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
-	require.NoError(t, err)
-	postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
-	require.NoError(t, err, "Failed to decompress")
-	postBeaconState, err := sszToState(postBeaconStateSSZ)
-	require.NoError(t, err)
-	postBeaconStatePb, ok := postBeaconState.ToProtoUnsafe().(proto.Message)
-	require.Equal(t, true, ok, "post beacon state did not return a proto.Message")
-	pbState, ok := want.ToProtoUnsafe().(proto.Message)
-	require.Equal(t, true, ok, "beacon state did not return a proto.Message")
-
-	if !proto.Equal(postBeaconStatePb, pbState) {
-		diff := cmp.Diff(pbState, postBeaconStatePb, protocmp.Transform())
-		t.Fatalf("Post state does not match expected state, diff: %s", diff)
-	}
-}

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)
+}