Add gloas block gossip changes

Adds Gloas fork attestation validation rules for gossip processing. This
implements the new committee index validation requirements introduced in
the Gloas fork.

## Changes
- Uses attestation epoch to determine if Gloas rules apply
- **Committee index validation**: 
  - Committee index must be < 2 (0 or 1 only)
- Same-slot attestations (where `attestation.data.slot == block.slot`)
must use committee index 0
  - Different-slot attestations can use either committee index 0 or 1

api/server/structs/BUILD.bazel

@@ -9,7 +9,6 @@ go_library(
         "conversions_blob.go",
         "conversions_block.go",
         "conversions_block_execution.go",
-        "conversions_gloas.go",
         "conversions_lightclient.go",
         "conversions_state.go",
         "endpoints_beacon.go",
@@ -58,12 +57,10 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//consensus-types/blocks:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
     ],

api/server/structs/conversions_gloas.go

@@ -1,84 +0,0 @@
-package structs
-
-import (
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-)
-
-func ROExecutionPayloadBidFromConsensus(b interfaces.ROExecutionPayloadBid) *ExecutionPayloadBid {
-	pbh := b.ParentBlockHash()
-	pbr := b.ParentBlockRoot()
-	bh := b.BlockHash()
-	pr := b.PrevRandao()
-	fr := b.FeeRecipient()
-	var blobKzgCommitments []string
-	for _, commitment := range b.BlobKzgCommitments() {
-		blobKzgCommitments = append(blobKzgCommitments, hexutil.Encode(commitment))
-	}
-	return &ExecutionPayloadBid{
-		ParentBlockHash:    hexutil.Encode(pbh[:]),
-		ParentBlockRoot:    hexutil.Encode(pbr[:]),
-		BlockHash:          hexutil.Encode(bh[:]),
-		PrevRandao:         hexutil.Encode(pr[:]),
-		FeeRecipient:       hexutil.Encode(fr[:]),
-		GasLimit:           fmt.Sprintf("%d", b.GasLimit()),
-		BuilderIndex:       fmt.Sprintf("%d", b.BuilderIndex()),
-		Slot:               fmt.Sprintf("%d", b.Slot()),
-		Value:              fmt.Sprintf("%d", b.Value()),
-		ExecutionPayment:   fmt.Sprintf("%d", b.ExecutionPayment()),
-		BlobKzgCommitments: blobKzgCommitments,
-	}
-}
-
-func BuildersFromConsensus(builders []*ethpb.Builder) []*Builder {
-	newBuilders := make([]*Builder, len(builders))
-	for i, b := range builders {
-		newBuilders[i] = BuilderFromConsensus(b)
-	}
-	return newBuilders
-}
-
-func BuilderFromConsensus(b *ethpb.Builder) *Builder {
-	return &Builder{
-		Pubkey:            hexutil.Encode(b.Pubkey),
-		Version:           hexutil.Encode(b.Version),
-		ExecutionAddress:  hexutil.Encode(b.ExecutionAddress),
-		Balance:           fmt.Sprintf("%d", b.Balance),
-		DepositEpoch:      fmt.Sprintf("%d", b.DepositEpoch),
-		WithdrawableEpoch: fmt.Sprintf("%d", b.WithdrawableEpoch),
-	}
-}
-
-func BuilderPendingPaymentsFromConsensus(payments []*ethpb.BuilderPendingPayment) []*BuilderPendingPayment {
-	newPayments := make([]*BuilderPendingPayment, len(payments))
-	for i, p := range payments {
-		newPayments[i] = BuilderPendingPaymentFromConsensus(p)
-	}
-	return newPayments
-}
-
-func BuilderPendingPaymentFromConsensus(p *ethpb.BuilderPendingPayment) *BuilderPendingPayment {
-	return &BuilderPendingPayment{
-		Weight:     fmt.Sprintf("%d", p.Weight),
-		Withdrawal: BuilderPendingWithdrawalFromConsensus(p.Withdrawal),
-	}
-}
-
-func BuilderPendingWithdrawalsFromConsensus(withdrawals []*ethpb.BuilderPendingWithdrawal) []*BuilderPendingWithdrawal {
-	newWithdrawals := make([]*BuilderPendingWithdrawal, len(withdrawals))
-	for i, w := range withdrawals {
-		newWithdrawals[i] = BuilderPendingWithdrawalFromConsensus(w)
-	}
-	return newWithdrawals
-}
-
-func BuilderPendingWithdrawalFromConsensus(w *ethpb.BuilderPendingWithdrawal) *BuilderPendingWithdrawal {
-	return &BuilderPendingWithdrawal{
-		FeeRecipient: hexutil.Encode(w.FeeRecipient),
-		Amount:       fmt.Sprintf("%d", w.Amount),
-		BuilderIndex: fmt.Sprintf("%d", w.BuilderIndex),
-	}
-}

api/server/structs/conversions_state.go

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

api/server/structs/conversions_test.go

@@ -1,15 +1,11 @@
 package structs
 
 import (
-	"bytes"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/testing/assert"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
@@ -359,178 +355,3 @@ func TestIndexedAttestation_ToConsensus(t *testing.T) {
 	_, err := a.ToConsensus()
 	require.ErrorContains(t, errNilValue.Error(), err)
 }
-
-func TestROExecutionPayloadBidFromConsensus(t *testing.T) {
-	bid := &eth.ExecutionPayloadBid{
-		ParentBlockHash:    bytes.Repeat([]byte{0x01}, 32),
-		ParentBlockRoot:    bytes.Repeat([]byte{0x02}, 32),
-		BlockHash:          bytes.Repeat([]byte{0x03}, 32),
-		PrevRandao:         bytes.Repeat([]byte{0x04}, 32),
-		FeeRecipient:       bytes.Repeat([]byte{0x05}, 20),
-		GasLimit:           100,
-		BuilderIndex:       7,
-		Slot:               9,
-		Value:              11,
-		ExecutionPayment:   22,
-		BlobKzgCommitments: [][]byte{bytes.Repeat([]byte{0x06}, 48)},
-	}
-	roBid, err := blocks.WrappedROExecutionPayloadBid(bid)
-	require.NoError(t, err)
-
-	var bkcs []string
-	for _, commitment := range roBid.BlobKzgCommitments() {
-		bkcs = append(bkcs, hexutil.Encode(commitment))
-	}
-
-	got := ROExecutionPayloadBidFromConsensus(roBid)
-	want := &ExecutionPayloadBid{
-		ParentBlockHash:    hexutil.Encode(bid.ParentBlockHash),
-		ParentBlockRoot:    hexutil.Encode(bid.ParentBlockRoot),
-		BlockHash:          hexutil.Encode(bid.BlockHash),
-		PrevRandao:         hexutil.Encode(bid.PrevRandao),
-		FeeRecipient:       hexutil.Encode(bid.FeeRecipient),
-		GasLimit:           "100",
-		BuilderIndex:       "7",
-		Slot:               "9",
-		Value:              "11",
-		ExecutionPayment:   "22",
-		BlobKzgCommitments: bkcs,
-	}
-	assert.DeepEqual(t, want, got)
-}
-
-func TestBuilderConversionsFromConsensus(t *testing.T) {
-	builder := &eth.Builder{
-		Pubkey:            bytes.Repeat([]byte{0xAA}, 48),
-		Version:           bytes.Repeat([]byte{0x01}, 4),
-		ExecutionAddress:  bytes.Repeat([]byte{0xBB}, 20),
-		Balance:           42,
-		DepositEpoch:      3,
-		WithdrawableEpoch: 4,
-	}
-	wantBuilder := &Builder{
-		Pubkey:            hexutil.Encode(builder.Pubkey),
-		Version:           hexutil.Encode(builder.Version),
-		ExecutionAddress:  hexutil.Encode(builder.ExecutionAddress),
-		Balance:           "42",
-		DepositEpoch:      "3",
-		WithdrawableEpoch: "4",
-	}
-
-	assert.DeepEqual(t, wantBuilder, BuilderFromConsensus(builder))
-	assert.DeepEqual(t, []*Builder{wantBuilder}, BuildersFromConsensus([]*eth.Builder{builder}))
-}
-
-func TestBuilderPendingPaymentConversionsFromConsensus(t *testing.T) {
-	withdrawal := &eth.BuilderPendingWithdrawal{
-		FeeRecipient: bytes.Repeat([]byte{0x10}, 20),
-		Amount:       15,
-		BuilderIndex: 2,
-	}
-	payment := &eth.BuilderPendingPayment{
-		Weight:     5,
-		Withdrawal: withdrawal,
-	}
-	wantWithdrawal := &BuilderPendingWithdrawal{
-		FeeRecipient: hexutil.Encode(withdrawal.FeeRecipient),
-		Amount:       "15",
-		BuilderIndex: "2",
-	}
-	wantPayment := &BuilderPendingPayment{
-		Weight:     "5",
-		Withdrawal: wantWithdrawal,
-	}
-
-	assert.DeepEqual(t, wantPayment, BuilderPendingPaymentFromConsensus(payment))
-	assert.DeepEqual(t, []*BuilderPendingPayment{wantPayment}, BuilderPendingPaymentsFromConsensus([]*eth.BuilderPendingPayment{payment}))
-	assert.DeepEqual(t, wantWithdrawal, BuilderPendingWithdrawalFromConsensus(withdrawal))
-	assert.DeepEqual(t, []*BuilderPendingWithdrawal{wantWithdrawal}, BuilderPendingWithdrawalsFromConsensus([]*eth.BuilderPendingWithdrawal{withdrawal}))
-}
-
-func TestBeaconStateGloasFromConsensus(t *testing.T) {
-	st, err := util.NewBeaconStateGloas(func(state *eth.BeaconStateGloas) error {
-		state.GenesisTime = 123
-		state.GenesisValidatorsRoot = bytes.Repeat([]byte{0x10}, 32)
-		state.Slot = 5
-		state.ProposerLookahead = []uint64{1, 2}
-		state.LatestExecutionPayloadBid = &eth.ExecutionPayloadBid{
-			ParentBlockHash:    bytes.Repeat([]byte{0x11}, 32),
-			ParentBlockRoot:    bytes.Repeat([]byte{0x12}, 32),
-			BlockHash:          bytes.Repeat([]byte{0x13}, 32),
-			PrevRandao:         bytes.Repeat([]byte{0x14}, 32),
-			FeeRecipient:       bytes.Repeat([]byte{0x15}, 20),
-			GasLimit:           64,
-			BuilderIndex:       3,
-			Slot:               5,
-			Value:              99,
-			ExecutionPayment:   7,
-			BlobKzgCommitments: [][]byte{bytes.Repeat([]byte{0x16}, 48)},
-		}
-		state.Builders = []*eth.Builder{
-			{
-				Pubkey:            bytes.Repeat([]byte{0x20}, 48),
-				Version:           bytes.Repeat([]byte{0x21}, 4),
-				ExecutionAddress:  bytes.Repeat([]byte{0x22}, 20),
-				Balance:           88,
-				DepositEpoch:      1,
-				WithdrawableEpoch: 2,
-			},
-		}
-		state.NextWithdrawalBuilderIndex = 9
-		state.ExecutionPayloadAvailability = []byte{0x01, 0x02}
-		state.BuilderPendingPayments = []*eth.BuilderPendingPayment{
-			{
-				Weight: 3,
-				Withdrawal: &eth.BuilderPendingWithdrawal{
-					FeeRecipient: bytes.Repeat([]byte{0x23}, 20),
-					Amount:       4,
-					BuilderIndex: 5,
-				},
-			},
-		}
-		state.BuilderPendingWithdrawals = []*eth.BuilderPendingWithdrawal{
-			{
-				FeeRecipient: bytes.Repeat([]byte{0x24}, 20),
-				Amount:       6,
-				BuilderIndex: 7,
-			},
-		}
-		state.LatestBlockHash = bytes.Repeat([]byte{0x25}, 32)
-		state.PayloadExpectedWithdrawals = []*enginev1.Withdrawal{
-			{Index: 1, ValidatorIndex: 2, Address: bytes.Repeat([]byte{0x26}, 20), Amount: 10},
-		}
-		return nil
-	})
-	require.NoError(t, err)
-
-	got, err := BeaconStateGloasFromConsensus(st)
-	require.NoError(t, err)
-
-	require.Equal(t, "123", got.GenesisTime)
-	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x10}, 32)), got.GenesisValidatorsRoot)
-	require.Equal(t, "5", got.Slot)
-	require.DeepEqual(t, []string{"1", "2"}, got.ProposerLookahead)
-	require.Equal(t, "9", got.NextWithdrawalBuilderIndex)
-	require.Equal(t, hexutil.Encode([]byte{0x01, 0x02}), got.ExecutionPayloadAvailability)
-	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x25}, 32)), got.LatestBlockHash)
-
-	require.NotNil(t, got.LatestExecutionPayloadBid)
-	require.Equal(t, "64", got.LatestExecutionPayloadBid.GasLimit)
-	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x11}, 32)), got.LatestExecutionPayloadBid.ParentBlockHash)
-
-	require.NotNil(t, got.Builders)
-	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x20}, 48)), got.Builders[0].Pubkey)
-	require.Equal(t, "88", got.Builders[0].Balance)
-
-	require.Equal(t, "3", got.BuilderPendingPayments[0].Weight)
-	require.Equal(t, "4", got.BuilderPendingPayments[0].Withdrawal.Amount)
-	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x23}, 20)), got.BuilderPendingPayments[0].Withdrawal.FeeRecipient)
-
-	require.Equal(t, "6", got.BuilderPendingWithdrawals[0].Amount)
-	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x24}, 20)), got.BuilderPendingWithdrawals[0].FeeRecipient)
-
-	require.Equal(t, "1", got.PayloadExpectedWithdrawals[0].WithdrawalIndex)
-	require.Equal(t, "2", got.PayloadExpectedWithdrawals[0].ValidatorIndex)
-	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x26}, 20)), got.PayloadExpectedWithdrawals[0].ExecutionAddress)
-	require.Equal(t, "10", got.PayloadExpectedWithdrawals[0].Amount)
-}

api/server/structs/other.go

@@ -262,23 +262,3 @@ type PendingConsolidation struct {
 	SourceIndex string `json:"source_index"`
 	TargetIndex string `json:"target_index"`
 }
-
-type Builder struct {
-	Pubkey            string `json:"pubkey"`
-	Version           string `json:"version"`
-	ExecutionAddress  string `json:"execution_address"`
-	Balance           string `json:"balance"`
-	DepositEpoch      string `json:"deposit_epoch"`
-	WithdrawableEpoch string `json:"withdrawable_epoch"`
-}
-
-type BuilderPendingPayment struct {
-	Weight     string                    `json:"weight"`
-	Withdrawal *BuilderPendingWithdrawal `json:"withdrawal"`
-}
-
-type BuilderPendingWithdrawal struct {
-	FeeRecipient string `json:"fee_recipient"`
-	Amount       string `json:"amount"`
-	BuilderIndex string `json:"builder_index"`
-}

api/server/structs/state.go

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

beacon-chain/core/gloas/payload.go

@@ -112,6 +112,34 @@ func ProcessExecutionPayload(
 		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")
+	}
+
+	if err := ApplyExecutionPayload(ctx, st, envelope); err != nil {
+		return err
+	}
+
+	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
+}
+
+// ApplyExecutionPayload applies the execution payload envelope to the state and performs the same
+// consistency checks as the full processing path. This keeps the post-payload state root computation
+// on a shared code path, even though some bid/payload checks are not strictly required for the root itself.
+func ApplyExecutionPayload(
+	ctx context.Context,
+	st state.BeaconState,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
 	latestHeader := st.LatestBlockHeader()
 	if len(latestHeader.StateRoot) == 0 || bytes.Equal(latestHeader.StateRoot, make([]byte, 32)) {
 		previousStateRoot, err := st.HashTreeRoot(ctx)
@@ -128,10 +156,6 @@ func ProcessExecutionPayload(
 	if err != nil {
 		return errors.Wrap(err, "could not compute block header root")
 	}
-	envelope, err := signedEnvelope.Envelope()
-	if err != nil {
-		return errors.Wrap(err, "could not get envelope from signed envelope")
-	}
 
 	beaconBlockRoot := envelope.BeaconBlockRoot()
 	if !bytes.Equal(beaconBlockRoot[:], blockHeaderRoot[:]) {
@@ -217,14 +241,6 @@ func ProcessExecutionPayload(
 		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
 }
 

beacon-chain/core/peerdas/validator.go

@@ -73,23 +73,22 @@ func PopulateFromSidecar(sidecar blocks.VerifiedRODataColumn) *SidecarReconstruc
 
 // ValidatorsCustodyRequirement returns the number of custody groups regarding the validator indices attached to the beacon node.
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#validator-custody
-func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validatorsIndex map[primitives.ValidatorIndex]bool) (uint64, error) {
-	totalNodeBalance := uint64(0)
+func ValidatorsCustodyRequirement(st beaconState.ReadOnlyBalances, validatorsIndex map[primitives.ValidatorIndex]bool) (uint64, error) {
+	cfg := params.BeaconConfig()
+	idxs := make([]primitives.ValidatorIndex, 0, len(validatorsIndex))
 	for index := range validatorsIndex {
-		validator, err := state.ValidatorAtIndexReadOnly(index)
-		if err != nil {
-			return 0, errors.Wrapf(err, "validator at index %v", index)
-		}
-
-		totalNodeBalance += validator.EffectiveBalance()
+		idxs = append(idxs, index)
+	}
+	totalBalance, err := st.EffectiveBalanceSum(idxs)
+	if err != nil {
+		return 0, errors.Wrap(err, "effective balances")
 	}
 
-	cfg := params.BeaconConfig()
 	numberOfCustodyGroups := cfg.NumberOfCustodyGroups
 	validatorCustodyRequirement := cfg.ValidatorCustodyRequirement
 	balancePerAdditionalCustodyGroup := cfg.BalancePerAdditionalCustodyGroup
 
-	count := totalNodeBalance / balancePerAdditionalCustodyGroup
+	count := totalBalance / balancePerAdditionalCustodyGroup
 	return min(max(count, validatorCustodyRequirement), numberOfCustodyGroups), nil
 }
 

beacon-chain/state/interfaces.go

@@ -152,6 +152,7 @@ type ReadOnlyBalances interface {
 	Balances() []uint64
 	BalanceAtIndex(idx primitives.ValidatorIndex) (uint64, error)
 	BalancesLength() int
+	EffectiveBalanceSum([]primitives.ValidatorIndex) (uint64, error)
 }
 
 // ReadOnlyCheckpoint defines a struct which only has read access to checkpoint methods.

beacon-chain/state/interfaces_gloas.go

@@ -39,15 +39,12 @@ type readOnlyGloasFields interface {
 	// Builder pending payments / withdrawals.
 	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
 	WithdrawalsMatchPayloadExpected(withdrawals []*enginev1.Withdrawal) (bool, error)
-	BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error)
-	PayloadExpectedWithdrawals() ([]*enginev1.Withdrawal, error)
 
 	// Misc.
 	LatestBlockHash() ([32]byte, error)
 
 	// Builders.
 	Builder(index primitives.BuilderIndex) (*ethpb.Builder, error)
-	Builders() ([]*ethpb.Builder, error)
 	BuilderPubkey(primitives.BuilderIndex) ([48]byte, error)
 	BuilderIndexByPubkey(pubkey [fieldparams.BLSPubkeyLength]byte) (primitives.BuilderIndex, bool)
 	IsActiveBuilder(primitives.BuilderIndex) (bool, error)
@@ -55,6 +52,4 @@ type readOnlyGloasFields interface {
 	IsAttestationSameSlot(blockRoot [32]byte, slot primitives.Slot) (bool, error)
 	BuilderPendingPayment(index uint64) (*ethpb.BuilderPendingPayment, error)
 	ExecutionPayloadAvailability(slot primitives.Slot) (uint64, error)
-	ExecutionPayloadAvailabilityVector() ([]byte, error)
-	NextWithdrawalBuilderIndex() (primitives.BuilderIndex, error)
 }

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

@@ -281,18 +281,6 @@ func (b *BeaconState) ExecutionPayloadAvailability(slot primitives.Slot) (uint64
 	return uint64(bit), nil
 }
 
-// ExecutionPayloadAvailabilityVector returns a copy of the execution payload availability bitvector.
-func (b *BeaconState) ExecutionPayloadAvailabilityVector() ([]byte, error) {
-	if b.version < version.Gloas {
-		return nil, errNotSupported("ExecutionPayloadAvailabilityVector", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return b.executionPayloadAvailabilityVal(), nil
-}
-
 // Builder returns the builder at the given index.
 func (b *BeaconState) Builder(index primitives.BuilderIndex) (*ethpb.Builder, error) {
 	b.lock.RLock()
@@ -326,51 +314,3 @@ func (b *BeaconState) BuilderIndexByPubkey(pubkey [fieldparams.BLSPubkeyLength]b
 	}
 	return 0, false
 }
-
-// BuilderPendingWithdrawals returns a copy of the builder pending withdrawals.
-func (b *BeaconState) BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error) {
-	if b.version < version.Gloas {
-		return nil, errNotSupported("BuilderPendingWithdrawals", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return b.builderPendingWithdrawalsVal(), nil
-}
-
-// PayloadExpectedWithdrawals returns a copy of the payload expected withdrawals.
-func (b *BeaconState) PayloadExpectedWithdrawals() ([]*enginev1.Withdrawal, error) {
-	if b.version < version.Gloas {
-		return nil, errNotSupported("PayloadExpectedWithdrawals", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return b.payloadExpectedWithdrawalsVal(), nil
-}
-
-// Builders returns a copy of the builders registry.
-func (b *BeaconState) Builders() ([]*ethpb.Builder, error) {
-	if b.version < version.Gloas {
-		return nil, errNotSupported("Builders", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return b.buildersVal(), nil
-}
-
-// NextWithdrawalBuilderIndex returns the next withdrawal builder index.
-func (b *BeaconState) NextWithdrawalBuilderIndex() (primitives.BuilderIndex, error) {
-	if b.version < version.Gloas {
-		return 0, errNotSupported("NextWithdrawalBuilderIndex", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return b.nextWithdrawalBuilderIndex, nil
-}

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

@@ -470,150 +470,3 @@ func TestExecutionPayloadAvailability(t *testing.T) {
 		require.Equal(t, uint64(0), otherBit)
 	})
 }
-
-func TestBuilderPendingWithdrawals(t *testing.T) {
-	t.Run("returns error before gloas", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
-		require.NoError(t, err)
-		st := stIface.(*state_native.BeaconState)
-
-		_, err = st.BuilderPendingWithdrawals()
-		require.ErrorContains(t, "BuilderPendingWithdrawals", err)
-	})
-
-	t.Run("returns copy", func(t *testing.T) {
-		original := []*ethpb.BuilderPendingWithdrawal{
-			{Amount: 10, BuilderIndex: 1},
-		}
-		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			BuilderPendingWithdrawals: original,
-		})
-		require.NoError(t, err)
-
-		got1, err := st.BuilderPendingWithdrawals()
-		require.NoError(t, err)
-		require.DeepEqual(t, original, got1)
-
-		got1[0].Amount = 99
-		got2, err := st.BuilderPendingWithdrawals()
-		require.NoError(t, err)
-		require.DeepEqual(t, original, got2)
-	})
-}
-
-func TestBuildersGetter(t *testing.T) {
-	t.Run("returns error before gloas", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
-		require.NoError(t, err)
-		st := stIface.(*state_native.BeaconState)
-
-		_, err = st.Builders()
-		require.ErrorContains(t, "Builders", err)
-	})
-
-	t.Run("returns copy", func(t *testing.T) {
-		pubkey := bytes.Repeat([]byte{0xAB}, fieldparams.BLSPubkeyLength)
-		buildr := &ethpb.Builder{
-			Pubkey:            pubkey,
-			Balance:           42,
-			DepositEpoch:      3,
-			WithdrawableEpoch: 4,
-		}
-		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			Builders: []*ethpb.Builder{buildr},
-		})
-		require.NoError(t, err)
-
-		got1, err := st.Builders()
-		require.NoError(t, err)
-		require.DeepEqual(t, buildr, got1[0])
-
-		got1[0].Pubkey[0] = 0xFF
-		got2, err := st.Builders()
-		require.NoError(t, err)
-		require.DeepEqual(t, buildr, got2[0])
-	})
-}
-
-func TestNextWithdrawalBuilderIndex(t *testing.T) {
-	t.Run("returns error before gloas", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
-		require.NoError(t, err)
-		st := stIface.(*state_native.BeaconState)
-
-		_, err = st.NextWithdrawalBuilderIndex()
-		require.ErrorContains(t, "NextWithdrawalBuilderIndex", err)
-	})
-
-	t.Run("returns configured value", func(t *testing.T) {
-		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			NextWithdrawalBuilderIndex: 2,
-		})
-		require.NoError(t, err)
-
-		got, err := st.NextWithdrawalBuilderIndex()
-		require.NoError(t, err)
-		require.Equal(t, primitives.BuilderIndex(2), got)
-	})
-}
-
-func TestPayloadExpectedWithdrawals(t *testing.T) {
-	t.Run("returns error before gloas", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
-		require.NoError(t, err)
-		st := stIface.(*state_native.BeaconState)
-
-		_, err = st.PayloadExpectedWithdrawals()
-		require.ErrorContains(t, "PayloadExpectedWithdrawals", err)
-	})
-
-	t.Run("returns copy", func(t *testing.T) {
-		original := enginev1.Withdrawal{
-			Index:          1,
-			ValidatorIndex: 2,
-			Address:        bytes.Repeat([]byte{0x01}, 20),
-			Amount:         10,
-		}
-		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			PayloadExpectedWithdrawals: []*enginev1.Withdrawal{&original},
-		})
-		require.NoError(t, err)
-
-		got1, err := st.PayloadExpectedWithdrawals()
-		require.NoError(t, err)
-		require.DeepEqual(t, &original, got1[0])
-
-		got1[0].Amount = 99
-		got2, err := st.PayloadExpectedWithdrawals()
-		require.NoError(t, err)
-		require.DeepEqual(t, &original, got2[0])
-	})
-}
-
-func TestExecutionPayloadAvailabilityVector(t *testing.T) {
-	t.Run("returns error before gloas", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
-		require.NoError(t, err)
-		st := stIface.(*state_native.BeaconState)
-
-		_, err = st.ExecutionPayloadAvailabilityVector()
-		require.ErrorContains(t, "ExecutionPayloadAvailabilityVector", err)
-	})
-
-	t.Run("returns copy", func(t *testing.T) {
-		availability := []byte{0xAA, 0xBB, 0xCC}
-		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			ExecutionPayloadAvailability: availability,
-		})
-		require.NoError(t, err)
-
-		got1, err := st.ExecutionPayloadAvailabilityVector()
-		require.NoError(t, err)
-		require.DeepEqual(t, availability, got1)
-
-		got1[0] = 0xFF
-		got2, err := st.ExecutionPayloadAvailabilityVector()
-		require.NoError(t, err)
-		require.DeepEqual(t, availability, got2)
-	})
-}

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

@@ -8,6 +8,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/pkg/errors"
 )
 
 // Validators participating in consensus on the beacon chain.
@@ -80,6 +81,25 @@ func (b *BeaconState) ValidatorAtIndex(idx primitives.ValidatorIndex) (*ethpb.Va
 	return b.validatorAtIndex(idx)
 }
 
+// EffectiveBalances returns the sum of the effective balances of the given list of validator indices, the eb of each given validator, or an
+// error if one of the indices is out of bounds, or the state wasn't correctly initialized.
+func (b *BeaconState) EffectiveBalanceSum(idxs []primitives.ValidatorIndex) (uint64, error) {
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+	var sum uint64
+	for i := range idxs {
+		if b.validatorsMultiValue == nil {
+			return 0, errors.Wrap(state.ErrNilValidatorsInState, "nil validators multi-value slice")
+		}
+		v, err := b.validatorsMultiValue.At(b, uint64(idxs[i]))
+		if err != nil {
+			return 0, errors.Wrap(err, "validators multi value at index")
+		}
+		sum += v.EffectiveBalance
+	}
+	return sum, nil
+}
+
 func (b *BeaconState) validatorAtIndex(idx primitives.ValidatorIndex) (*ethpb.Validator, error) {
 	if b.validatorsMultiValue == nil {
 		return &ethpb.Validator{}, nil

beacon-chain/state/stategen/mock/mock.go

@@ -5,6 +5,7 @@ import (
 	"context"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stategen"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 )
 
@@ -14,6 +15,8 @@ type StateManager struct {
 	StatesBySlot map[primitives.Slot]state.BeaconState
 }
 
+var _ stategen.StateManager = (*StateManager)(nil)
+
 // NewService --
 func NewService() *StateManager {
 	return &StateManager{
@@ -101,3 +104,8 @@ func (m *StateManager) AddStateForSlot(state state.BeaconState, slot primitives.
 func (m *StateManager) DeleteStateFromCaches(context.Context, [32]byte) error {
 	return nil
 }
+
+// FinalizedReadOnlyBalances --
+func (m *StateManager) FinalizedReadOnlyBalances() stategen.NilCheckableReadOnlyBalances {
+	panic("unimplemented")
+}

beacon-chain/state/stategen/service.go

@@ -27,6 +27,13 @@ var defaultHotStateDBInterval primitives.Slot = 128
 
 var populatePubkeyCacheOnce sync.Once
 
+// NilCheckableReadOnlyBalances adds the IsNil method to ReadOnlyBalances
+// to allow checking if the underlying state value is nil.
+type NilCheckableReadOnlyBalances interface {
+	state.ReadOnlyBalances
+	IsNil() bool
+}
+
 // StateManager represents a management object that handles the internal
 // logic of maintaining both hot and cold states in DB.
 type StateManager interface {
@@ -43,6 +50,7 @@ type StateManager interface {
 	ActiveNonSlashedBalancesByRoot(context.Context, [32]byte) ([]uint64, error)
 	StateByRootIfCachedNoCopy(blockRoot [32]byte) state.BeaconState
 	StateByRootInitialSync(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
+	FinalizedReadOnlyBalances() NilCheckableReadOnlyBalances
 }
 
 // State is a concrete implementation of StateManager.
@@ -201,3 +209,8 @@ func (s *State) FinalizedState() state.BeaconState {
 	defer s.finalizedInfo.lock.RUnlock()
 	return s.finalizedInfo.state.Copy()
 }
+
+// Returns the finalized state as a ReadOnlyBalances so that it can be used read-only without copying.
+func (s *State) FinalizedReadOnlyBalances() NilCheckableReadOnlyBalances {
+	return s.finalizedInfo.state
+}

beacon-chain/sync/BUILD.bazel

@@ -54,6 +54,7 @@ go_library(
         "validate_aggregate_proof.go",
         "validate_attester_slashing.go",
         "validate_beacon_attestation.go",
+        "validate_beacon_block_gloas.go",
         "validate_beacon_blocks.go",
         "validate_blob.go",
         "validate_bls_to_execution_change.go",
@@ -211,6 +212,7 @@ go_test(
         "validate_aggregate_proof_test.go",
         "validate_attester_slashing_test.go",
         "validate_beacon_attestation_test.go",
+        "validate_beacon_block_gloas_test.go",
         "validate_beacon_blocks_test.go",
         "validate_blob_test.go",
         "validate_bls_to_execution_change_test.go",

beacon-chain/sync/custody.go

@@ -185,7 +185,7 @@ func (s *Service) validatorsCustodyRequirement() (uint64, error) {
 	}
 
 	// Retrieve the finalized state.
-	finalizedState := s.cfg.stateGen.FinalizedState()
+	finalizedState := s.cfg.stateGen.FinalizedReadOnlyBalances()
 	if finalizedState == nil || finalizedState.IsNil() {
 		return 0, nilFinalizedStateError
 	}

beacon-chain/sync/validate_beacon_attestation.go

@@ -268,10 +268,23 @@ func (s *Service) validateCommitteeIndexAndCount(
 	a eth.Att,
 	bs state.ReadOnlyBeaconState,
 ) (primitives.CommitteeIndex, uint64, pubsub.ValidationResult, error) {
-	// - [REJECT] attestation.data.index == 0
-	if a.Version() >= version.Electra && a.GetData().CommitteeIndex != 0 {
-		return 0, 0, pubsub.ValidationReject, errors.New("attestation data's committee index must be 0")
+	// Validate committee index based on fork.
+	if a.Version() >= version.Electra {
+		data := a.GetData()
+		attEpoch := slots.ToEpoch(data.Slot)
+		postGloas := attEpoch >= params.BeaconConfig().GloasForkEpoch
+		if postGloas {
+			if result, err := s.validateGloasCommitteeIndex(data); result != pubsub.ValidationAccept {
+				return 0, 0, result, err
+			}
+		} else {
+			// [REJECT] attestation.data.index == 0 (New in Electra, removed in Gloas)
+			if data.CommitteeIndex != 0 {
+				return 0, 0, pubsub.ValidationReject, errors.New("attestation data's committee index must be 0")
+			}
+		}
 	}
+
 	valCount, err := helpers.ActiveValidatorCount(ctx, bs, slots.ToEpoch(a.GetData().Slot))
 	if err != nil {
 		return 0, 0, pubsub.ValidationIgnore, err
@@ -356,6 +369,29 @@ func validateAttestingIndex(
 	return pubsub.ValidationAccept, nil
 }
 
+// validateGloasCommitteeIndex validates committee index rules for Gloas fork.
+// [REJECT] attestation.data.index < 2. (New in Gloas)
+// [REJECT] attestation.data.index == 0 if block.slot == attestation.data.slot. (New in Gloas)
+func (s *Service) validateGloasCommitteeIndex(data *eth.AttestationData) (pubsub.ValidationResult, error) {
+	if data.CommitteeIndex >= 2 {
+		return pubsub.ValidationReject, errors.New("attestation data's committee index must be < 2")
+	}
+
+	// Same-slot attestations must use committee index 0
+	if data.CommitteeIndex != 0 {
+		blockRoot := bytesutil.ToBytes32(data.BeaconBlockRoot)
+		slot, err := s.cfg.chain.RecentBlockSlot(blockRoot)
+		if err != nil {
+			return pubsub.ValidationIgnore, err
+		}
+		if slot == data.Slot {
+			return pubsub.ValidationReject, errors.New("same slot attestations must use committee index 0")
+		}
+	}
+
+	return pubsub.ValidationAccept, nil
+}
+
 // generateUnaggregatedAttCacheKey generates the cache key for unaggregated attestation tracking.
 func generateUnaggregatedAttCacheKey(att eth.Att) (string, error) {
 	var attester uint64

beacon-chain/sync/validate_beacon_attestation_test.go

@@ -684,3 +684,75 @@ func Test_validateCommitteeIndexAndCount_Boundary(t *testing.T) {
 	require.ErrorContains(t, "committee index", err)
 	require.Equal(t, pubsub.ValidationReject, res)
 }
+
+func Test_validateGloasCommitteeIndex(t *testing.T) {
+	tests := []struct {
+		name           string
+		committeeIndex primitives.CommitteeIndex
+		attestationSlot primitives.Slot
+		blockSlot      primitives.Slot
+		wantResult     pubsub.ValidationResult
+		wantErr        string
+	}{
+		{
+			name:           "committee index >= 2 should reject",
+			committeeIndex: 2,
+			attestationSlot: 10,
+			blockSlot:      10,
+			wantResult:     pubsub.ValidationReject,
+			wantErr:        "committee index must be < 2",
+		},
+		{
+			name:           "committee index 0 should accept",
+			committeeIndex: 0,
+			attestationSlot: 10,
+			blockSlot:      10,
+			wantResult:     pubsub.ValidationAccept,
+			wantErr:        "",
+		},
+		{
+			name:           "committee index 1 different-slot should accept",
+			committeeIndex: 1,
+			attestationSlot: 10,
+			blockSlot:      9,
+			wantResult:     pubsub.ValidationAccept,
+			wantErr:        "",
+		},
+		{
+			name:           "committee index 1 same-slot should reject",
+			committeeIndex: 1,
+			attestationSlot: 10,
+			blockSlot:      10,
+			wantResult:     pubsub.ValidationReject,
+			wantErr:        "same slot attestations must use committee index 0",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockChain := &mockChain.ChainService{
+				BlockSlot: tt.blockSlot,
+			}
+			s := &Service{
+				cfg: &config{
+					chain: mockChain,
+				},
+			}
+
+			data := &ethpb.AttestationData{
+				Slot:            tt.attestationSlot,
+				CommitteeIndex:  tt.committeeIndex,
+				BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot"), 32),
+			}
+
+			result, err := s.validateGloasCommitteeIndex(data)
+
+			require.Equal(t, tt.wantResult, result)
+			if tt.wantErr != "" {
+				require.ErrorContains(t, tt.wantErr, err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

beacon-chain/sync/validate_beacon_block_gloas.go

@@ -0,0 +1,61 @@
+package sync
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	consensusblocks "github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/pkg/errors"
+)
+
+// validateExecutionPayloadBid validates execution payload bid gossip rules.
+// [REJECT] The bid's parent (defined by bid.parent_block_root) equals the block's parent (defined by block.parent_root).
+// [REJECT] The length of KZG commitments is less than or equal to the limitation defined in the consensus layer --
+// i.e. validate that len(bid.blob_kzg_commitments) <= get_blob_parameters(get_current_epoch(state)).max_blobs_per_block
+func (s *Service) validateExecutionPayloadBid(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock) (pubsub.ValidationResult, error) {
+	if blk.Version() < version.Gloas {
+		return pubsub.ValidationAccept, nil
+	}
+	signedBid, err := blk.Body().SignedExecutionPayloadBid()
+	if err != nil {
+		return pubsub.ValidationIgnore, errors.Wrap(err, "unable to read bid from block")
+	}
+	wrappedBid, err := consensusblocks.WrappedROSignedExecutionPayloadBid(signedBid)
+	if err != nil {
+		return pubsub.ValidationIgnore, errors.Wrap(err, "unable to wrap signed execution payload bid")
+	}
+	bid, err := wrappedBid.Bid()
+	if err != nil {
+		return pubsub.ValidationIgnore, errors.Wrap(err, "unable to read bid from signed execution payload bid")
+	}
+
+	if bid.ParentBlockRoot() != blk.ParentRoot() {
+		return pubsub.ValidationReject, errors.New("bid parent block root does not match block parent root")
+	}
+
+	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlockAtEpoch(slots.ToEpoch(blk.Slot()))
+	if bid.BlobKzgCommitmentCount() > uint64(maxBlobsPerBlock) {
+		return pubsub.ValidationReject, errors.Wrapf(errRejectCommitmentLen, "%d > %d", bid.BlobKzgCommitmentCount(), maxBlobsPerBlock)
+	}
+	return pubsub.ValidationAccept, nil
+}
+
+// validateExecutionPayloadBidParentSeen validates parent payload gossip rules.
+// [IGNORE] The block's parent execution payload (defined by bid.parent_block_hash) has been seen
+// (via gossip or non-gossip sources) (a client MAY queue blocks for processing once the parent payload is retrieved).
+func (s *Service) validateExecutionPayloadBidParentSeen(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock) (pubsub.ValidationResult, error) {
+	// TODO: Requires blockchain service changes to expose parent payload seen status
+	return pubsub.ValidationAccept, nil
+}
+
+// validateExecutionPayloadBidParentValid validates parent payload verification status.
+// If execution_payload verification of block's execution payload parent by an execution node is complete:
+// [REJECT] The block's execution payload parent (defined by bid.parent_block_hash) passes all validation.
+func (s *Service) validateExecutionPayloadBidParentValid(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock) (pubsub.ValidationResult, error) {
+	// TODO: Requires blockchain service changes to expose execution payload parent validation status.
+	return pubsub.ValidationAccept, nil
+}

beacon-chain/sync/validate_beacon_block_gloas_test.go

@@ -0,0 +1,75 @@
+package sync
+
+import (
+	"context"
+	"testing"
+
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/stretchr/testify/require"
+)
+
+func TestValidateExecutionPayloadBid_Accept(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	ctx := context.Background()
+
+	parentRoot := bytesutil.PadTo([]byte{0x01}, fieldparams.RootLength)
+	block := util.NewBeaconBlockGloas()
+	block.Block.ParentRoot = parentRoot
+	block.Block.Body.SignedExecutionPayloadBid.Message.ParentBlockRoot = parentRoot
+	block.Block.Body.SignedExecutionPayloadBid.Message.BlobKzgCommitments = nil
+
+	wsb, err := blocks.NewSignedBeaconBlock(block)
+	require.NoError(t, err)
+
+	s := &Service{}
+	res, err := s.validateExecutionPayloadBid(ctx, wsb.Block())
+	require.NoError(t, err)
+	require.Equal(t, pubsub.ValidationAccept, res)
+}
+
+func TestValidateExecutionPayloadBid_RejectParentRootMismatch(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	ctx := context.Background()
+
+	block := util.NewBeaconBlockGloas()
+	block.Block.ParentRoot = bytesutil.PadTo([]byte{0x01}, fieldparams.RootLength)
+	block.Block.Body.SignedExecutionPayloadBid.Message.ParentBlockRoot = bytesutil.PadTo([]byte{0x02}, fieldparams.RootLength)
+
+	wsb, err := blocks.NewSignedBeaconBlock(block)
+	require.NoError(t, err)
+
+	s := &Service{}
+	res, err := s.validateExecutionPayloadBid(ctx, wsb.Block())
+	require.Error(t, err)
+	require.Equal(t, pubsub.ValidationReject, res)
+}
+
+func TestValidateExecutionPayloadBid_RejectTooManyCommitments(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	ctx := context.Background()
+
+	parentRoot := bytesutil.PadTo([]byte{0x01}, fieldparams.RootLength)
+	block := util.NewBeaconBlockGloas()
+	block.Block.ParentRoot = parentRoot
+	block.Block.Body.SignedExecutionPayloadBid.Message.ParentBlockRoot = parentRoot
+
+	maxBlobs := params.BeaconConfig().MaxBlobsPerBlockAtEpoch(0)
+	commitments := make([][]byte, maxBlobs+1)
+	for i := range commitments {
+		commitments[i] = bytesutil.PadTo([]byte{0x02}, fieldparams.BLSPubkeyLength)
+	}
+	block.Block.Body.SignedExecutionPayloadBid.Message.BlobKzgCommitments = commitments
+
+	wsb, err := blocks.NewSignedBeaconBlock(block)
+	require.NoError(t, err)
+
+	s := &Service{}
+	res, err := s.validateExecutionPayloadBid(ctx, wsb.Block())
+	require.Error(t, err)
+	require.Equal(t, pubsub.ValidationReject, res)
+}

beacon-chain/sync/validate_beacon_blocks.go

@@ -127,6 +127,9 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 		log.WithError(err).WithFields(getBlockFields(blk)).Debug("Received block with an invalid parent")
 		return pubsub.ValidationReject, err
 	}
+	if res, err := s.validateExecutionPayloadBidParentValid(ctx, blk.Block()); err != nil {
+		return res, err
+	}
 
 	s.pendingQueueLock.RLock()
 	if s.seenPendingBlocks[blockRoot] {
@@ -198,6 +201,16 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 		log.WithError(err).WithFields(getBlockFields(blk)).Debug("Could not identify parent for block")
 		return pubsub.ValidationIgnore, err
 	}
+	if res, err := s.validateExecutionPayloadBidParentSeen(ctx, blk.Block()); err != nil {
+		return res, err
+	}
+
+	if res, err := s.validateExecutionPayloadBid(ctx, blk.Block()); err != nil {
+		if res == pubsub.ValidationReject {
+			s.setBadBlock(ctx, blockRoot)
+		}
+		return res, err
+	}
 
 	err = s.validateBeaconBlock(ctx, blk, blockRoot)
 	if err != nil {
@@ -365,7 +378,7 @@ func (s *Service) blockVerifyingState(ctx context.Context, blk interfaces.ReadOn
 }
 
 func validateDenebBeaconBlock(blk interfaces.ReadOnlyBeaconBlock) error {
-	if blk.Version() < version.Deneb {
+	if blk.Version() < version.Deneb || blk.Version() >= version.Gloas {
 		return nil
 	}
 	commits, err := blk.Body().BlobKzgCommitments()
@@ -398,6 +411,10 @@ func validateDenebBeaconBlock(blk interfaces.ReadOnlyBeaconBlock) error {
 //	      [IGNORE] The block's parent (defined by block.parent_root) passes all validation (including execution
 //	       node verification of the block.body.execution_payload).
 func (s *Service) validateBellatrixBeaconBlock(ctx context.Context, verifyingState state.ReadOnlyBeaconState, blk interfaces.ReadOnlyBeaconBlock) error {
+	if blk.Version() >= version.Gloas {
+		return nil
+	}
+
 	// Error if block and state are not the same version
 	if verifyingState.Version() != blk.Version() {
 		return errors.New("block and state are not the same version")

changelog/bastin_gloas-state-api-structs.md

@@ -1,3 +0,0 @@
-### Added
-
-- Gloas state API structs.

changelog/kasey_copy-free-balance-lookup.md

@@ -0,0 +1,2 @@
+### Fixed
+- Avoid copying the full finalized state every time we compute cgc.

changelog/terence_gloas-attestation-validation.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add gossip beacon attestation validation conditions for Gloas fork

changelog/terence_gloas-beacon-block-bid-gossip-validation.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add Gloas beacon block gossip validation for execution payload bids

changelog/tt_apply_execution_payload.md

@@ -0,0 +1,2 @@
+### Ignored
+- Refactor ProcessExecutionPayload to ApplyExecutionPayload