spectests

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/blockchain/chain_info.go

@@ -46,6 +46,7 @@ type ForkchoiceFetcher interface {
 	HighestReceivedBlockSlot() primitives.Slot
 	ReceivedBlocksLastEpoch() (uint64, error)
 	InsertNode(context.Context, state.BeaconState, consensus_blocks.ROBlock) error
+	InsertPayload(context.Context, interfaces.ROExecutionPayloadEnvelope) error
 	ForkChoiceDump(context.Context) (*forkchoice.Dump, error)
 	NewSlot(context.Context, primitives.Slot) error
 	ProposerBoost() [32]byte

beacon-chain/blockchain/chain_info_forkchoice.go

@@ -7,6 +7,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	consensus_blocks "github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/forkchoice"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
@@ -55,6 +56,13 @@ func (s *Service) InsertNode(ctx context.Context, st state.BeaconState, block co
 	return s.cfg.ForkChoiceStore.InsertNode(ctx, st, block)
 }
 
+// InsertPayload is a wrapper for payload insertion which is self locked
+func (s *Service) InsertPayload(ctx context.Context, pe interfaces.ROExecutionPayloadEnvelope) error {
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
+	return s.cfg.ForkChoiceStore.InsertPayload(ctx, pe)
+}
+
 // ForkChoiceDump returns the corresponding value from forkchoice
 func (s *Service) ForkChoiceDump(ctx context.Context) (*forkchoice.Dump, error) {
 	s.cfg.ForkChoiceStore.RLock()

beacon-chain/blockchain/execution_engine_test.go

@@ -429,9 +429,9 @@ func Test_NotifyForkchoiceUpdateRecursive_DoublyLinkedTree(t *testing.T) {
 
 	// Insert Attestations to D, F and G so that they have higher weight than D
 	// Ensure G is head
-	fcs.ProcessAttestation(ctx, []uint64{0}, brd, 1)
-	fcs.ProcessAttestation(ctx, []uint64{1}, brf, 1)
-	fcs.ProcessAttestation(ctx, []uint64{2}, brg, 1)
+	fcs.ProcessAttestation(ctx, []uint64{0}, brd, params.BeaconConfig().SlotsPerEpoch, true)
+	fcs.ProcessAttestation(ctx, []uint64{1}, brf, params.BeaconConfig().SlotsPerEpoch, true)
+	fcs.ProcessAttestation(ctx, []uint64{2}, brg, params.BeaconConfig().SlotsPerEpoch, true)
 	fcs.SetBalancesByRooter(service.cfg.StateGen.ActiveNonSlashedBalancesByRoot)
 	jc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: bra}
 	require.NoError(t, fcs.UpdateJustifiedCheckpoint(ctx, jc))

beacon-chain/blockchain/process_attestation.go

@@ -96,7 +96,11 @@ func (s *Service) OnAttestation(ctx context.Context, a ethpb.Att, disparity time
 	// We assume trusted attestation in this function has verified signature.
 
 	// Update forkchoice store with the new attestation for updating weight.
-	s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indexedAtt.GetAttestingIndices(), bytesutil.ToBytes32(a.GetData().BeaconBlockRoot), a.GetData().Target.Epoch)
-
+	attData := a.GetData()
+	payloadStatus := true
+	if attData.Target.Epoch >= params.BeaconConfig().GloasForkEpoch {
+		payloadStatus = attData.CommitteeIndex == 1
+	}
+	s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indexedAtt.GetAttestingIndices(), bytesutil.ToBytes32(attData.BeaconBlockRoot), attData.Slot, payloadStatus)
 	return nil
 }

beacon-chain/blockchain/process_block.go

@@ -402,7 +402,11 @@ func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.Re
 		}
 		r := bytesutil.ToBytes32(a.GetData().BeaconBlockRoot)
 		if s.cfg.ForkChoiceStore.HasNode(r) {
-			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Target.Epoch)
+			payloadStatus := true
+			if a.GetData().Target.Epoch >= params.BeaconConfig().GloasForkEpoch {
+				payloadStatus = a.GetData().CommitteeIndex == 1
+			}
+			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Slot, payloadStatus)
 		} else if features.Get().EnableExperimentalAttestationPool {
 			if err = s.cfg.AttestationCache.Add(a); err != nil {
 				return err

beacon-chain/blockchain/testing/mock.go

@@ -700,6 +700,14 @@ func (s *ChainService) InsertNode(ctx context.Context, st state.BeaconState, blo
 	return nil
 }
 
+// InsertPayload mocks the same method in the chain service
+func (s *ChainService) InsertPayload(ctx context.Context, pe interfaces.ROExecutionPayloadEnvelope) error {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.InsertPayload(ctx, pe)
+	}
+	return nil
+}
+
 // ForkChoiceDump mocks the same method in the chain service
 func (s *ChainService) ForkChoiceDump(ctx context.Context) (*forkchoice2.Dump, error) {
 	if s.ForkChoiceStore != nil {

beacon-chain/forkchoice/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
         "//config/fieldparams:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/forkchoice:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],

beacon-chain/forkchoice/doubly-linked-tree/BUILD.bazel

@@ -52,6 +52,7 @@ go_test(
     srcs = [
         "ffg_update_test.go",
         "forkchoice_test.go",
+        "gloas_test.go",
         "no_vote_test.go",
         "node_test.go",
         "on_tick_test.go",
@@ -71,6 +72,7 @@ go_test(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/forkchoice:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/forkchoice/doubly-linked-tree/ffg_update_test.go

@@ -161,7 +161,7 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	//               7   8
 	//               |   |
 	//               9  10
-	f.ProcessAttestation(t.Context(), []uint64{0}, indexToHash(1), 0)
+	f.ProcessAttestation(t.Context(), []uint64{0}, indexToHash(1), 0, true)
 
 	// With the additional vote to the left branch, the head should be 9:
 	//           0  <-- start
@@ -191,7 +191,7 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	//               7   8
 	//               |   |
 	//               9  10
-	f.ProcessAttestation(t.Context(), []uint64{1}, indexToHash(2), 0)
+	f.ProcessAttestation(t.Context(), []uint64{1}, indexToHash(2), 0, true)
 
 	// With the additional vote to the right branch, the head should be 10:
 	//           0  <-- start

beacon-chain/forkchoice/doubly-linked-tree/forkchoice.go

@@ -80,24 +80,25 @@ func (f *ForkChoice) Head(
 
 // ProcessAttestation processes attestation for vote accounting, it iterates around validator indices
 // and update their votes accordingly.
-func (f *ForkChoice) ProcessAttestation(ctx context.Context, validatorIndices []uint64, blockRoot [32]byte, targetEpoch primitives.Epoch) {
+func (f *ForkChoice) ProcessAttestation(ctx context.Context, validatorIndices []uint64, blockRoot [32]byte, slot primitives.Slot, payloadStatus bool) {
 	_, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.ProcessAttestation")
 	defer span.End()
 
 	for _, index := range validatorIndices {
 		// Validator indices will grow the vote cache.
+		newVote := false
 		for index >= uint64(len(f.votes)) {
 			f.votes = append(f.votes, Vote{currentRoot: params.BeaconConfig().ZeroHash, nextRoot: params.BeaconConfig().ZeroHash})
+			newVote = true
 		}
 
-		// Newly allocated vote if the root fields are untouched.
-		newVote := f.votes[index].nextRoot == params.BeaconConfig().ZeroHash &&
-			f.votes[index].currentRoot == params.BeaconConfig().ZeroHash
-
 		// Vote gets updated if it's newly allocated or high target epoch.
-		if newVote || targetEpoch > f.votes[index].nextEpoch {
-			f.votes[index].nextEpoch = targetEpoch
+		targetEpoch := slots.ToEpoch(slot)
+		nextEpoch := slots.ToEpoch(f.votes[index].nextSlot)
+		if newVote || targetEpoch > nextEpoch {
+			f.votes[index].nextSlot = slot
 			f.votes[index].nextRoot = blockRoot
+			f.votes[index].nextPayloadStatus = payloadStatus
 		}
 	}
 
@@ -311,40 +312,57 @@ func (f *ForkChoice) updateBalances() error {
 		if vote.currentRoot != vote.nextRoot || oldBalance != newBalance {
 			// Ignore the vote if the root is not in fork choice
 			// store, that means we have not seen the block before.
-			nextNode, ok := f.store.emptyNodeByRoot[vote.nextRoot]
-			if ok && vote.nextRoot != zHash {
-				// Protection against nil node
-				if nextNode == nil {
-					return errors.Wrap(ErrNilNode, "could not update balances")
-				}
-				nextNode.balance += newBalance
+			pn, pending := f.store.resolveVoteNode(vote.nextRoot, vote.nextSlot, vote.nextPayloadStatus)
+			if pn == nil {
+				// TODO: check cl-spec #4918
+				continue
+			}
+			if pending {
+				pn.node.balance += newBalance
+			} else {
+				pn.balance += newBalance
 			}
 
-			currentNode, ok := f.store.emptyNodeByRoot[vote.currentRoot]
-			if ok && vote.currentRoot != zHash {
-				// Protection against nil node
-				if currentNode == nil {
-					return errors.Wrap(ErrNilNode, "could not update balances")
-				}
-				if currentNode.balance < oldBalance {
+			pn, pending = f.store.resolveVoteNode(vote.currentRoot, vote.currentSlot, vote.currentPayloadStatus)
+			if pn == nil {
+				continue
+			}
+			if pending {
+				if pn.node.balance < oldBalance {
 					log.WithFields(logrus.Fields{
 						"nodeRoot":                   fmt.Sprintf("%#x", bytesutil.Trunc(vote.currentRoot[:])),
 						"oldBalance":                 oldBalance,
-						"nodeBalance":                currentNode.balance,
-						"nodeWeight":                 currentNode.weight,
+						"nodeBalance":                pn.node.balance,
+						"nodeWeight":                 pn.node.weight,
 						"proposerBoostRoot":          fmt.Sprintf("%#x", bytesutil.Trunc(f.store.proposerBoostRoot[:])),
 						"previousProposerBoostRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(f.store.previousProposerBoostRoot[:])),
 						"previousProposerBoostScore": f.store.previousProposerBoostScore,
 					}).Warning("node with invalid balance, setting it to zero")
-					currentNode.balance = 0
+					pn.node.balance = 0
 				} else {
-					currentNode.balance -= oldBalance
+					pn.node.balance -= oldBalance
+				}
+			} else {
+				if pn.balance < oldBalance {
+					log.WithFields(logrus.Fields{
+						"nodeRoot":                   fmt.Sprintf("%#x", bytesutil.Trunc(vote.currentRoot[:])),
+						"oldBalance":                 oldBalance,
+						"nodeBalance":                pn.balance,
+						"nodeWeight":                 pn.weight,
+						"proposerBoostRoot":          fmt.Sprintf("%#x", bytesutil.Trunc(f.store.proposerBoostRoot[:])),
+						"previousProposerBoostRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(f.store.previousProposerBoostRoot[:])),
+						"previousProposerBoostScore": f.store.previousProposerBoostScore,
+					}).Warning("node with invalid balance, setting it to zero")
+					pn.balance = 0
+				} else {
+					pn.balance -= oldBalance
 				}
 			}
 		}
-
 		// Rotate the validator vote.
 		f.votes[index].currentRoot = vote.nextRoot
+		f.votes[index].currentSlot = vote.nextSlot
+		f.votes[index].currentPayloadStatus = vote.nextPayloadStatus
 	}
 	f.balances = newBalances
 	return nil
@@ -410,15 +428,23 @@ func (f *ForkChoice) InsertSlashedIndex(_ context.Context, index primitives.Vali
 		return
 	}
 
-	node, ok := f.store.emptyNodeByRoot[f.votes[index].currentRoot]
-	if !ok || node == nil {
+	v := f.votes[index]
+	pn, pending := f.store.resolveVoteNode(v.currentRoot, v.currentSlot, v.currentPayloadStatus)
+	if pn == nil {
 		return
 	}
-
-	if node.balance < f.balances[index] {
-		node.balance = 0
+	if pending {
+		if pn.node.balance < f.balances[index] {
+			pn.node.balance = 0
+		} else {
+			pn.node.balance -= f.balances[index]
+		}
+		return
+	}
+	if pn.balance < f.balances[index] {
+		pn.balance = 0
 	} else {
-		node.balance -= f.balances[index]
+		pn.balance -= f.balances[index]
 	}
 }
 

beacon-chain/forkchoice/doubly-linked-tree/forkchoice_test.go

@@ -93,9 +93,9 @@ func TestForkChoice_UpdateBalancesPositiveChange(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
 	f.votes = []Vote{
-		{indexToHash(1), indexToHash(1), 0},
-		{indexToHash(2), indexToHash(2), 0},
-		{indexToHash(3), indexToHash(3), 0},
+		{indexToHash(1), indexToHash(1), 0, 0, true, true},
+		{indexToHash(2), indexToHash(2), 0, 0, true, true},
+		{indexToHash(3), indexToHash(3), 0, 0, true, true},
 	}
 
 	// Each node gets one unique vote. The weight should look like 103 <- 102 <- 101 because
@@ -103,9 +103,9 @@ func TestForkChoice_UpdateBalancesPositiveChange(t *testing.T) {
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
 	s := f.store
-	assert.Equal(t, uint64(10), s.emptyNodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(20), s.emptyNodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(30), s.emptyNodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(10), s.fullNodeByRoot[indexToHash(1)].balance)
+	assert.Equal(t, uint64(20), s.fullNodeByRoot[indexToHash(2)].balance)
+	assert.Equal(t, uint64(30), s.fullNodeByRoot[indexToHash(3)].balance)
 }
 
 func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
@@ -121,22 +121,22 @@ func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 	s := f.store
-	s.emptyNodeByRoot[indexToHash(1)].balance = 100
-	s.emptyNodeByRoot[indexToHash(2)].balance = 100
-	s.emptyNodeByRoot[indexToHash(3)].balance = 100
+	s.fullNodeByRoot[indexToHash(1)].balance = 100
+	s.fullNodeByRoot[indexToHash(2)].balance = 100
+	s.fullNodeByRoot[indexToHash(3)].balance = 100
 
 	f.balances = []uint64{100, 100, 100}
 	f.votes = []Vote{
-		{indexToHash(1), indexToHash(1), 0},
-		{indexToHash(2), indexToHash(2), 0},
-		{indexToHash(3), indexToHash(3), 0},
+		{indexToHash(1), indexToHash(1), 0, 0, true, true},
+		{indexToHash(2), indexToHash(2), 0, 0, true, true},
+		{indexToHash(3), indexToHash(3), 0, 0, true, true},
 	}
 
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
-	assert.Equal(t, uint64(10), s.emptyNodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(20), s.emptyNodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(30), s.emptyNodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(10), s.fullNodeByRoot[indexToHash(1)].balance)
+	assert.Equal(t, uint64(20), s.fullNodeByRoot[indexToHash(2)].balance)
+	assert.Equal(t, uint64(30), s.fullNodeByRoot[indexToHash(3)].balance)
 }
 
 func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) {
@@ -152,22 +152,22 @@ func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 	s := f.store
-	s.emptyNodeByRoot[indexToHash(1)].balance = 100
-	s.emptyNodeByRoot[indexToHash(2)].balance = 100
-	s.emptyNodeByRoot[indexToHash(3)].balance = 100
+	s.fullNodeByRoot[indexToHash(1)].balance = 100
+	s.fullNodeByRoot[indexToHash(2)].balance = 100
+	s.fullNodeByRoot[indexToHash(3)].balance = 100
 
 	f.balances = []uint64{125, 125, 125}
 	f.votes = []Vote{
-		{indexToHash(1), indexToHash(1), 0},
-		{indexToHash(2), indexToHash(2), 0},
-		{indexToHash(3), indexToHash(3), 0},
+		{indexToHash(1), indexToHash(1), 0, 0, true, true},
+		{indexToHash(2), indexToHash(2), 0, 0, true, true},
+		{indexToHash(3), indexToHash(3), 0, 0, true, true},
 	}
 
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
-	assert.Equal(t, uint64(0), s.emptyNodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(0), s.emptyNodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(5), s.emptyNodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(0), s.fullNodeByRoot[indexToHash(1)].balance)
+	assert.Equal(t, uint64(0), s.fullNodeByRoot[indexToHash(2)].balance)
+	assert.Equal(t, uint64(5), s.fullNodeByRoot[indexToHash(3)].balance)
 }
 
 func TestForkChoice_IsCanonical(t *testing.T) {
@@ -332,8 +332,8 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 	require.Equal(t, [32]byte{'c'}, head)
 
 	// Insert two attestations for block b, one for c it becomes head
-	f.ProcessAttestation(ctx, []uint64{1, 2}, [32]byte{'b'}, 1)
-	f.ProcessAttestation(ctx, []uint64{3}, [32]byte{'c'}, 1)
+	f.ProcessAttestation(ctx, []uint64{1, 2}, [32]byte{'b'}, params.BeaconConfig().SlotsPerEpoch, true)
+	f.ProcessAttestation(ctx, []uint64{3}, [32]byte{'c'}, params.BeaconConfig().SlotsPerEpoch, true)
 	f.justifiedBalances = []uint64{100, 200, 200, 300}
 	head, err = f.Head(ctx)
 	require.NoError(t, err)
@@ -341,21 +341,21 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 
 	// Process b's slashing, c is now head
 	f.InsertSlashedIndex(ctx, 1)
-	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].balance)
+	require.Equal(t, uint64(200), f.store.fullNodeByRoot[[32]byte{'b'}].balance)
 	f.justifiedBalances = []uint64{100, 200, 200, 300}
 	head, err = f.Head(ctx)
-	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].weight)
-	require.Equal(t, uint64(300), f.store.emptyNodeByRoot[[32]byte{'c'}].weight)
+	require.Equal(t, uint64(200), f.store.fullNodeByRoot[[32]byte{'b'}].weight)
+	require.Equal(t, uint64(300), f.store.fullNodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 
 	// Process b's slashing again, should be a noop
 	f.InsertSlashedIndex(ctx, 1)
-	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].balance)
+	require.Equal(t, uint64(200), f.store.fullNodeByRoot[[32]byte{'b'}].balance)
 	f.justifiedBalances = []uint64{100, 200, 200, 300}
 	head, err = f.Head(ctx)
-	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].weight)
-	require.Equal(t, uint64(300), f.store.emptyNodeByRoot[[32]byte{'c'}].weight)
+	require.Equal(t, uint64(200), f.store.fullNodeByRoot[[32]byte{'b'}].weight)
+	require.Equal(t, uint64(300), f.store.fullNodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 

beacon-chain/forkchoice/doubly-linked-tree/gloas.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"slices"
+	"time"
 
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
@@ -287,3 +288,50 @@ func (s *Store) nodeTreeDump(ctx context.Context, n *Node, nodes []*forkchoice2.
 	}
 	return nodes, nil
 }
+
+// InsertPayload inserts a full node into forkchoice after the Gloas fork.
+func (f *ForkChoice) InsertPayload(ctx context.Context, pe interfaces.ROExecutionPayloadEnvelope) error {
+	s := f.store
+	root := pe.BeaconBlockRoot()
+	en := s.emptyNodeByRoot[root]
+	if en == nil {
+		return errors.Wrap(ErrNilNode, "cannot insert full node without an empty one")
+	}
+	if _, ok := s.fullNodeByRoot[root]; ok {
+		// We don't import two payloads for the same root
+		return nil
+	}
+	fn := &PayloadNode{
+		node:       en.node,
+		optimistic: true,
+		timestamp:  time.Now(),
+		full:       true,
+		children:   make([]*Node, 0),
+	}
+	s.fullNodeByRoot[root] = fn
+	f.updateNewFullNodeWeight(fn)
+	return nil
+}
+
+func (f *ForkChoice) updateNewFullNodeWeight(fn *PayloadNode) {
+	for index, vote := range f.votes {
+		if vote.currentRoot == fn.node.root && vote.nextPayloadStatus && index < len(f.balances) {
+			fn.balance += f.balances[index]
+		}
+	}
+	fn.balance = fn.weight
+}
+
+func (s *Store) resolveVoteNode(r [32]byte, slot primitives.Slot, payloadStatus bool) (*PayloadNode, bool) {
+	en := s.emptyNodeByRoot[r]
+	if en == nil {
+		return nil, true
+	}
+	if payloadStatus {
+		return s.fullNodeByRoot[r], false
+	} else if slot == en.node.slot {
+		return en, true
+	} else {
+		return en, false
+	}
+}

beacon-chain/forkchoice/doubly-linked-tree/gloas_test.go

@@ -0,0 +1,300 @@
+package doublylinkedtree
+
+import (
+	"context"
+	"testing"
+
+	"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"
+	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"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+)
+
+func prepareGloasForkchoiceState(
+	_ context.Context,
+	slot primitives.Slot,
+	blockRoot [32]byte,
+	parentRoot [32]byte,
+	blockHash [32]byte,
+	parentBlockHash [32]byte,
+	justifiedEpoch primitives.Epoch,
+	finalizedEpoch primitives.Epoch,
+) (state.BeaconState, blocks.ROBlock, error) {
+	blockHeader := &ethpb.BeaconBlockHeader{
+		ParentRoot: parentRoot[:],
+	}
+
+	justifiedCheckpoint := &ethpb.Checkpoint{
+		Epoch: justifiedEpoch,
+	}
+
+	finalizedCheckpoint := &ethpb.Checkpoint{
+		Epoch: finalizedEpoch,
+	}
+
+	builderPendingPayments := make([]*ethpb.BuilderPendingPayment, 64)
+	for i := range builderPendingPayments {
+		builderPendingPayments[i] = &ethpb.BuilderPendingPayment{
+			Withdrawal: &ethpb.BuilderPendingWithdrawal{
+				FeeRecipient: make([]byte, 20),
+			},
+		}
+	}
+
+	base := &ethpb.BeaconStateGloas{
+		Slot:                       slot,
+		RandaoMixes:                make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+		CurrentJustifiedCheckpoint: justifiedCheckpoint,
+		FinalizedCheckpoint:        finalizedCheckpoint,
+		LatestBlockHeader:          blockHeader,
+		LatestExecutionPayloadBid: &ethpb.ExecutionPayloadBid{
+			BlockHash:          blockHash[:],
+			ParentBlockHash:    parentBlockHash[:],
+			ParentBlockRoot:    make([]byte, 32),
+			PrevRandao:         make([]byte, 32),
+			FeeRecipient:       make([]byte, 20),
+			BlobKzgCommitments: [][]byte{make([]byte, 48)},
+		},
+		Builders:                     make([]*ethpb.Builder, 0),
+		BuilderPendingPayments:       builderPendingPayments,
+		ExecutionPayloadAvailability: make([]byte, 1024),
+		LatestBlockHash:              make([]byte, 32),
+		PayloadExpectedWithdrawals:   make([]*enginev1.Withdrawal, 0),
+		ProposerLookahead:            make([]uint64, 64),
+	}
+
+	st, err := state_native.InitializeFromProtoUnsafeGloas(base)
+	if err != nil {
+		return nil, blocks.ROBlock{}, err
+	}
+
+	bid := util.HydrateSignedExecutionPayloadBid(&ethpb.SignedExecutionPayloadBid{
+		Message: &ethpb.ExecutionPayloadBid{
+			BlockHash:       blockHash[:],
+			ParentBlockHash: parentBlockHash[:],
+		},
+	})
+
+	blk := util.HydrateSignedBeaconBlockGloas(&ethpb.SignedBeaconBlockGloas{
+		Block: &ethpb.BeaconBlockGloas{
+			Slot:       slot,
+			ParentRoot: parentRoot[:],
+			Body: &ethpb.BeaconBlockBodyGloas{
+				SignedExecutionPayloadBid: bid,
+			},
+		},
+	})
+
+	signed, err := blocks.NewSignedBeaconBlock(blk)
+	if err != nil {
+		return nil, blocks.ROBlock{}, err
+	}
+	roblock, err := blocks.NewROBlockWithRoot(signed, blockRoot)
+	return st, roblock, err
+}
+
+func prepareGloasForkchoicePayload(
+	blockRoot [32]byte,
+) (interfaces.ROExecutionPayloadEnvelope, error) {
+	env := &ethpb.ExecutionPayloadEnvelope{
+		BeaconBlockRoot: blockRoot[:],
+		Payload:         &enginev1.ExecutionPayloadDeneb{},
+	}
+	return blocks.WrappedROExecutionPayloadEnvelope(env)
+}
+
+func TestInsertGloasBlock_EmptyNodeOnly(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	root := indexToHash(1)
+	blockHash := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, root, params.BeaconConfig().ZeroHash, blockHash, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	// Empty node should exist.
+	en := f.store.emptyNodeByRoot[root]
+	require.NotNil(t, en)
+
+	// Full node should NOT exist.
+	_, hasFull := f.store.fullNodeByRoot[root]
+	assert.Equal(t, false, hasFull)
+
+	// Parent should be the genesis full node.
+	genesisRoot := params.BeaconConfig().ZeroHash
+	genesisFull := f.store.fullNodeByRoot[genesisRoot]
+	require.NotNil(t, genesisFull)
+	assert.Equal(t, genesisFull, en.node.parent)
+}
+
+func TestInsertPayload_CreatesFullNode(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	root := indexToHash(1)
+	blockHash := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, root, params.BeaconConfig().ZeroHash, blockHash, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+	require.Equal(t, 2, len(f.store.emptyNodeByRoot))
+	require.Equal(t, 1, len(f.store.fullNodeByRoot))
+
+	pe, err := prepareGloasForkchoicePayload(root)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertPayload(ctx, pe))
+	require.Equal(t, 2, len(f.store.fullNodeByRoot))
+
+	fn := f.store.fullNodeByRoot[root]
+	require.NotNil(t, fn)
+
+	en := f.store.emptyNodeByRoot[root]
+	require.NotNil(t, en)
+
+	// Empty and full share the same *Node.
+	assert.Equal(t, en.node, fn.node)
+	assert.Equal(t, true, fn.optimistic)
+	assert.Equal(t, true, fn.full)
+}
+
+func TestInsertPayload_DuplicateIsNoop(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	root := indexToHash(1)
+	blockHash := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, root, params.BeaconConfig().ZeroHash, blockHash, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	pe, err := prepareGloasForkchoicePayload(root)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertPayload(ctx, pe))
+	require.Equal(t, 2, len(f.store.fullNodeByRoot))
+
+	fn := f.store.fullNodeByRoot[root]
+	require.NotNil(t, fn)
+
+	// Insert again — should be a no-op.
+	require.NoError(t, f.InsertPayload(ctx, pe))
+	assert.Equal(t, fn, f.store.fullNodeByRoot[root])
+	require.Equal(t, 2, len(f.store.fullNodeByRoot))
+}
+
+func TestInsertPayload_WithoutEmptyNode_Errors(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	root := indexToHash(99)
+	pe, err := prepareGloasForkchoicePayload(root)
+	require.NoError(t, err)
+
+	err = f.InsertPayload(ctx, pe)
+	require.ErrorContains(t, ErrNilNode.Error(), err)
+}
+
+func TestGloasBlock_ChildBuildsOnEmpty(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	// Insert Gloas block A (empty only).
+	rootA := indexToHash(1)
+	blockHashA := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, rootA, params.BeaconConfig().ZeroHash, blockHashA, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	// Insert Gloas block B as child of (A, empty)
+	rootB := indexToHash(2)
+	blockHashB := indexToHash(200)
+	nonMatchingParentHash := indexToHash(999)
+	st, roblock, err = prepareGloasForkchoiceState(ctx, 2, rootB, rootA, blockHashB, nonMatchingParentHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	emptyA := f.store.emptyNodeByRoot[rootA]
+	require.NotNil(t, emptyA)
+	nodeB := f.store.emptyNodeByRoot[rootB]
+	require.NotNil(t, nodeB)
+	require.Equal(t, emptyA, nodeB.node.parent)
+}
+
+func TestGloasBlock_ChildrenOfEmptyAndFull(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	// Insert Gloas block A (empty only).
+	rootA := indexToHash(1)
+	blockHashA := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, rootA, params.BeaconConfig().ZeroHash, blockHashA, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+	// Insert payload for A
+	pe, err := prepareGloasForkchoicePayload(rootA)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertPayload(ctx, pe))
+
+	// Insert Gloas block B as child of (A, empty)
+	rootB := indexToHash(2)
+	blockHashB := indexToHash(200)
+	nonMatchingParentHash := indexToHash(999)
+	st, roblock, err = prepareGloasForkchoiceState(ctx, 2, rootB, rootA, blockHashB, nonMatchingParentHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	// Insert Gloas block C as child of (A, full)
+	rootC := indexToHash(3)
+	blockHashC := indexToHash(201)
+	st, roblock, err = prepareGloasForkchoiceState(ctx, 3, rootC, rootA, blockHashC, blockHashA, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	emptyA := f.store.emptyNodeByRoot[rootA]
+	require.NotNil(t, emptyA)
+	nodeB := f.store.emptyNodeByRoot[rootB]
+	require.NotNil(t, nodeB)
+	require.Equal(t, emptyA, nodeB.node.parent)
+	nodeC := f.store.emptyNodeByRoot[rootC]
+	require.NotNil(t, nodeC)
+	fullA := f.store.fullNodeByRoot[rootA]
+	require.NotNil(t, fullA)
+	require.Equal(t, fullA, nodeC.node.parent)
+}
+
+func TestGloasBlock_ChildBuildsOnFull(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	// Insert Gloas block A (empty only).
+	rootA := indexToHash(1)
+	blockHashA := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, rootA, params.BeaconConfig().ZeroHash, blockHashA, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	// Insert payload for A → creates the full node.
+	pe, err := prepareGloasForkchoicePayload(rootA)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertPayload(ctx, pe))
+
+	fullA := f.store.fullNodeByRoot[rootA]
+	require.NotNil(t, fullA)
+
+	// Child for (A, full)
+	rootB := indexToHash(2)
+	blockHashB := indexToHash(200)
+	st, roblock, err = prepareGloasForkchoiceState(ctx, 2, rootB, rootA, blockHashB, blockHashA, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	nodeB := f.store.emptyNodeByRoot[rootB]
+	require.NotNil(t, nodeB)
+	assert.Equal(t, fullA, nodeB.node.parent)
+}

beacon-chain/forkchoice/doubly-linked-tree/proposer_boost_test.go

@@ -64,7 +64,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		f.ProcessAttestation(ctx, []uint64{0}, newRoot, fEpoch)
+		f.ProcessAttestation(ctx, []uint64{0}, newRoot, primitives.Slot(fEpoch), true)
 		headRoot, err = f.Head(ctx)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 1")
@@ -90,7 +90,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		f.ProcessAttestation(ctx, []uint64{1}, newRoot, fEpoch)
+		f.ProcessAttestation(ctx, []uint64{1}, newRoot, primitives.Slot(fEpoch), true)
 		headRoot, err = f.Head(ctx)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 2")
@@ -118,7 +118,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		f.ProcessAttestation(ctx, []uint64{2}, newRoot, fEpoch)
+		f.ProcessAttestation(ctx, []uint64{2}, newRoot, primitives.Slot(fEpoch), true)
 		headRoot, err = f.Head(ctx)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
@@ -147,7 +147,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		f.ProcessAttestation(ctx, []uint64{3}, newRoot, fEpoch)
+		f.ProcessAttestation(ctx, []uint64{3}, newRoot, primitives.Slot(fEpoch), true)
 		headRoot, err = f.Head(ctx)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
@@ -177,7 +177,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 
 		// Regression: process attestations for C, check that it
 		// becomes head, we need two attestations to have C.weight = 30 > 24 = D.weight
-		f.ProcessAttestation(ctx, []uint64{4, 5}, indexToHash(3), fEpoch)
+		f.ProcessAttestation(ctx, []uint64{4, 5}, indexToHash(3), primitives.Slot(fEpoch), true)
 		headRoot, err = f.Head(ctx)
 		require.NoError(t, err)
 		assert.Equal(t, indexToHash(3), headRoot, "Incorrect head for justified epoch at slot 4")
@@ -238,10 +238,10 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 
 		// The maliciously withheld block has one vote.
 		votes := []uint64{1}
-		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fEpoch)
+		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, primitives.Slot(fEpoch), true)
 		// The honest block has one vote.
 		votes = []uint64{2}
-		f.ProcessAttestation(ctx, votes, honestBlock, fEpoch)
+		f.ProcessAttestation(ctx, votes, honestBlock, primitives.Slot(fEpoch), true)
 
 		// Ensure the head is STILL C, the honest block, as the honest block had proposer boost.
 		r, err = f.Head(ctx)
@@ -307,7 +307,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		// An attestation is received for B that has more voting power than C with the proposer boost,
 		// allowing B to then become the head if their attestation has enough adversarial votes.
 		votes := []uint64{1, 2}
-		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fEpoch)
+		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, primitives.Slot(fEpoch), true)
 
 		// Expect the head to have switched to B.
 		r, err = f.Head(ctx)
@@ -382,7 +382,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 
 		// An attestation for C is received at slot N+3.
 		votes := []uint64{1}
-		f.ProcessAttestation(ctx, votes, c, fEpoch)
+		f.ProcessAttestation(ctx, votes, c, primitives.Slot(fEpoch), true)
 
 		// A block D, building on B, is received at slot N+3. It should not be able to win without boosting.
 		dSlot := primitives.Slot(3)
@@ -422,7 +422,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		votes = []uint64{2}
-		f.ProcessAttestation(ctx, votes, d2, fEpoch)
+		f.ProcessAttestation(ctx, votes, d2, primitives.Slot(fEpoch), true)
 		// Ensure D becomes the head thanks to boosting.
 		r, err = f.Head(ctx)
 		require.NoError(t, err)

beacon-chain/forkchoice/doubly-linked-tree/reorg_late_blocks_test.go

@@ -26,7 +26,7 @@ func TestForkChoice_ShouldOverrideFCU(t *testing.T) {
 	for i := range attesters {
 		attesters[i] = uint64(i + 64)
 	}
-	f.ProcessAttestation(ctx, attesters, blk.Root(), 0)
+	f.ProcessAttestation(ctx, attesters, blk.Root(), 0, true)
 
 	orphanLateBlockFirstThreshold := time.Duration(params.BeaconConfig().SecondsPerSlot/params.BeaconConfig().IntervalsPerSlot) * time.Second
 	driftGenesisTime(f, 2, orphanLateBlockFirstThreshold+time.Second)
@@ -124,7 +124,7 @@ func TestForkChoice_GetProposerHead(t *testing.T) {
 	for i := range attesters {
 		attesters[i] = uint64(i + 64)
 	}
-	f.ProcessAttestation(ctx, attesters, blk.Root(), 0)
+	f.ProcessAttestation(ctx, attesters, blk.Root(), 0, true)
 
 	driftGenesisTime(f, 3, 1*time.Second)
 	childRoot := [32]byte{'b'}

beacon-chain/forkchoice/doubly-linked-tree/store.go

@@ -136,6 +136,7 @@ func (s *Store) insert(ctx context.Context,
 		node:       n,
 		optimistic: optimistic,
 		timestamp:  time.Now(),
+		children:   make([]*Node, 0),
 	}
 	s.emptyNodeByRoot[root] = pn
 	ret = pn

beacon-chain/forkchoice/doubly-linked-tree/types.go

@@ -78,7 +78,10 @@ type PayloadNode struct {
 
 // Vote defines an individual validator's vote.
 type Vote struct {
-	currentRoot [fieldparams.RootLength]byte // current voting root.
-	nextRoot    [fieldparams.RootLength]byte // next voting root.
-	nextEpoch   primitives.Epoch             // epoch of next voting period.
+	currentRoot          [fieldparams.RootLength]byte // current voting root.
+	nextRoot             [fieldparams.RootLength]byte // next voting root.
+	nextSlot             primitives.Slot              // slot of the next voting period.
+	currentSlot          primitives.Slot              // slot of the current voting period.
+	nextPayloadStatus    bool                         // whether the next vote is for a full or empty payload
+	currentPayloadStatus bool                         // whether the current vote is for a full or empty payload
 }

beacon-chain/forkchoice/doubly-linked-tree/unrealized_justification_test.go

@@ -76,7 +76,7 @@ func TestStore_LongFork(t *testing.T) {
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'c'}, 2))
 
 	// Add an attestation to c, it is head
-	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'c'}, 1)
+	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'c'}, params.BeaconConfig().SlotsPerEpoch, true)
 	f.justifiedBalances = []uint64{100}
 	c := f.store.emptyNodeByRoot[[32]byte{'c'}]
 	require.Equal(t, primitives.Epoch(2), slots.ToEpoch(c.node.slot))
@@ -98,8 +98,8 @@ func TestStore_LongFork(t *testing.T) {
 	headRoot, err = f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, headRoot)
-	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].weight)
-	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'c'}].weight)
+	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].node.weight)
+	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'c'}].node.weight)
 }
 
 //	Epoch 1                Epoch 2               Epoch 3
@@ -153,7 +153,7 @@ func TestStore_NoDeadLock(t *testing.T) {
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'h'}, 2))
 	require.NoError(t, f.store.setUnrealizedFinalizedEpoch([32]byte{'h'}, 1))
 	// Add an attestation for h
-	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'h'}, 1)
+	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'h'}, params.BeaconConfig().SlotsPerEpoch, true)
 
 	// Epoch 3
 	// Current Head is H
@@ -225,7 +225,7 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 	// Insert an attestation to H, H is head
-	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'h'}, 1)
+	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'h'}, params.BeaconConfig().SlotsPerEpoch, true)
 	f.justifiedBalances = []uint64{100}
 	headRoot, err := f.Head(ctx)
 	require.NoError(t, err)
@@ -243,8 +243,8 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'d'}, headRoot)
 	require.Equal(t, primitives.Epoch(2), f.JustifiedCheckpoint().Epoch)
-	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].weight)
-	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'h'}].weight)
+	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].node.weight)
+	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'h'}].node.weight)
 	// Set current epoch to 3, and H's unrealized checkpoint. Check it's head
 	driftGenesisTime(f, 99, 0)
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'h'}, 2))
@@ -252,8 +252,8 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'h'}, headRoot)
 	require.Equal(t, primitives.Epoch(2), f.JustifiedCheckpoint().Epoch)
-	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].weight)
-	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'h'}].weight)
+	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].node.weight)
+	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'h'}].node.weight)
 }
 
 func TestStore_PullTips_Heuristics(t *testing.T) {

beacon-chain/forkchoice/doubly-linked-tree/vote_test.go

@@ -46,7 +46,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//            0
 	//           / \
 	//          2  1 <- +vote, new head
-	f.ProcessAttestation(t.Context(), []uint64{0}, indexToHash(1), 2)
+	f.ProcessAttestation(t.Context(), []uint64{0}, indexToHash(1), 2*params.BeaconConfig().SlotsPerEpoch, true)
 	r, err = f.Head(t.Context())
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(1), r, "Incorrect head for with justified epoch at 1")
@@ -55,7 +55,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//                     0
 	//                    / \
 	// vote, new head -> 2  1
-	f.ProcessAttestation(t.Context(), []uint64{1}, indexToHash(2), 2)
+	f.ProcessAttestation(t.Context(), []uint64{1}, indexToHash(2), 2*params.BeaconConfig().SlotsPerEpoch, true)
 	r, err = f.Head(t.Context())
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
@@ -80,7 +80,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//  head -> 2  1 <- old vote
 	//             |
 	//             3 <- new vote
-	f.ProcessAttestation(t.Context(), []uint64{0}, indexToHash(3), 3)
+	f.ProcessAttestation(t.Context(), []uint64{0}, indexToHash(3), 3*params.BeaconConfig().SlotsPerEpoch, true)
 	r, err = f.Head(t.Context())
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
@@ -91,7 +91,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	// old vote -> 2  1 <- new vote
 	//                |
 	//                3 <- head
-	f.ProcessAttestation(t.Context(), []uint64{1}, indexToHash(1), 3)
+	f.ProcessAttestation(t.Context(), []uint64{1}, indexToHash(1), 3*params.BeaconConfig().SlotsPerEpoch, true)
 	r, err = f.Head(t.Context())
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(3), r, "Incorrect head for with justified epoch at 1")
@@ -150,7 +150,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 3")
 
 	// Moved 2 votes to block 5:
-	f.ProcessAttestation(t.Context(), []uint64{0, 1}, indexToHash(5), 4)
+	f.ProcessAttestation(t.Context(), []uint64{0, 1}, indexToHash(5), 4*params.BeaconConfig().SlotsPerEpoch, true)
 
 	// Inset blocks 7 and 8
 	// 6 should still be the head, even though 5 has all the votes.
@@ -227,7 +227,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 
 	// Move two votes for 10, verify it's head
 
-	f.ProcessAttestation(t.Context(), []uint64{0, 1}, indexToHash(10), 5)
+	f.ProcessAttestation(t.Context(), []uint64{0, 1}, indexToHash(10), 5*params.BeaconConfig().SlotsPerEpoch, true)
 	r, err = f.Head(t.Context())
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(10), r, "Incorrect head for with justified epoch at 3")
@@ -235,7 +235,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	// Add 3 more validators to the system.
 	f.justifiedBalances = []uint64{1, 1, 1, 1, 1}
 	// The new validators voted for 9
-	f.ProcessAttestation(t.Context(), []uint64{2, 3, 4}, indexToHash(9), 5)
+	f.ProcessAttestation(t.Context(), []uint64{2, 3, 4}, indexToHash(9), 5*params.BeaconConfig().SlotsPerEpoch, true)
 	// The new head should be 9.
 	r, err = f.Head(t.Context())
 	require.NoError(t, err)

beacon-chain/forkchoice/interfaces.go

@@ -9,6 +9,7 @@ import (
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	consensus_blocks "github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	forkchoice2 "github.com/OffchainLabs/prysm/v7/consensus-types/forkchoice"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 )
 
@@ -23,6 +24,7 @@ type ForkChoicer interface {
 	Unlock()
 	HeadRetriever        // to compute head.
 	BlockProcessor       // to track new block for fork choice.
+	PayloadProcessor     // to track new payloads for fork choice.
 	AttestationProcessor // to track new attestation for fork choice.
 	Getter               // to retrieve fork choice information.
 	Setter               // to set fork choice information.
@@ -47,9 +49,14 @@ type BlockProcessor interface {
 	InsertChain(context.Context, []*forkchoicetypes.BlockAndCheckpoints) error
 }
 
+// PayloadProcessor processes a payload envelope
+type PayloadProcessor interface {
+	InsertPayload(context.Context, interfaces.ROExecutionPayloadEnvelope) error
+}
+
 // AttestationProcessor processes the attestation that's used for accounting fork choice.
 type AttestationProcessor interface {
-	ProcessAttestation(context.Context, []uint64, [32]byte, primitives.Epoch)
+	ProcessAttestation(context.Context, []uint64, [32]byte, primitives.Slot, bool)
 }
 
 // Getter returns fork choice related information.

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

changelog/bastin_gloas-state-api-structs.md

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

changelog/potuz_gloas_attestation_payload_status.md

@@ -0,0 +1,2 @@
+### Added
+- Process Gloas attestations in forkchoice.

changelog/potuz_gloas_forkchoice_insert_payload.md

@@ -0,0 +1,2 @@
+### Added
+- Added an InsertPayload method to allow full node insertion after gloas. 

testing/spectest/shared/common/forkchoice/builder.go

@@ -1,6 +1,7 @@
 package forkchoice
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -140,7 +141,7 @@ func (bb *Builder) Check(t testing.TB, c *Check) {
 	if c.Head != nil {
 		r, err := bb.service.HeadRoot(ctx)
 		require.NoError(t, err)
-		require.DeepEqual(t, common.FromHex(c.Head.Root), r)
+		require.Equal(t, true, bytes.Equal(common.FromHex(c.Head.Root), r))
 		require.Equal(t, primitives.Slot(c.Head.Slot), bb.service.HeadSlot())
 	}
 	if c.JustifiedCheckPoint != nil {