remove unused ctx

api/server/structs/endpoints_node.go

@@ -63,19 +63,6 @@ type PeerCount struct {
 	Connected     string `json:"connected"`
 	Disconnecting string `json:"disconnecting"`
 }
-type GetVersionV2Response struct {
-	Data *VersionV2 `json:"data"`
-}
-type VersionV2 struct {
-	BeaconNode      *ClientVersionV1 `json:"beacon_node"`
-	ExecutionClient *ClientVersionV1 `json:"execution_client,omitempty"`
-}
-type ClientVersionV1 struct {
-	Code    string `json:"code"`
-	Name    string `json:"name"`
-	Version string `json:"version"`
-	Commit  string `json:"commit"`
-}
 
 type GetVersionResponse struct {
 	Data *Version `json:"data"`

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(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(pe interfaces.ROExecutionPayloadEnvelope) error {
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
+	return s.cfg.ForkChoiceStore.InsertPayload(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/process_attestation_helpers.go

@@ -92,6 +92,10 @@ func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) st
 // getAttPreState retrieves the att pre state by either from the cache or the DB.
 // The caller of this function must have a lock on forkchoice.
 func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (state.ReadOnlyBeaconState, error) {
+	// If the attestation is recent and canonical we can use the head state to compute the shuffling.
+	if st := s.getRecentPreState(ctx, c); st != nil {
+		return st, nil
+	}
 	// Use a multilock to allow scoped holding of a mutex by a checkpoint root + epoch
 	// allowing us to behave smarter in terms of how this function is used concurrently.
 	epochKey := strconv.FormatUint(uint64(c.Epoch), 10 /* base 10 */)
@@ -124,10 +128,6 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (stat
 		}
 		return cachedState, nil
 	}
-	// If the attestation is recent and canonical we can use the head state to compute the shuffling.
-	if st := s.getRecentPreState(ctx, c); st != nil {
-		return st, nil
-	}
 
 	// Do not process attestations for old non viable checkpoints otherwise
 	ok, err := s.cfg.ForkChoiceStore.IsViableForCheckpoint(&forkchoicetypes.Checkpoint{Root: [32]byte(c.Root), Epoch: c.Epoch})

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(pe interfaces.ROExecutionPayloadEnvelope) error {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.InsertPayload(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/core/gloas/payload.go

@@ -112,34 +112,6 @@ 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)
@@ -156,6 +128,10 @@ func ApplyExecutionPayload(
 	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[:]) {
@@ -241,6 +217,14 @@ func ApplyExecutionPayload(
 		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,22 +73,23 @@ 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(st beaconState.ReadOnlyBalances, validatorsIndex map[primitives.ValidatorIndex]bool) (uint64, error) {
-	cfg := params.BeaconConfig()
-	idxs := make([]primitives.ValidatorIndex, 0, len(validatorsIndex))
+func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validatorsIndex map[primitives.ValidatorIndex]bool) (uint64, error) {
+	totalNodeBalance := uint64(0)
 	for index := range validatorsIndex {
-		idxs = append(idxs, index)
-	}
-	totalBalance, err := st.EffectiveBalanceSum(idxs)
-	if err != nil {
-		return 0, errors.Wrap(err, "effective balances")
+		validator, err := state.ValidatorAtIndexReadOnly(index)
+		if err != nil {
+			return 0, errors.Wrapf(err, "validator at index %v", index)
+		}
+
+		totalNodeBalance += validator.EffectiveBalance()
 	}
 
+	cfg := params.BeaconConfig()
 	numberOfCustodyGroups := cfg.NumberOfCustodyGroups
 	validatorCustodyRequirement := cfg.ValidatorCustodyRequirement
 	balancePerAdditionalCustodyGroup := cfg.BalancePerAdditionalCustodyGroup
 
-	count := totalBalance / balancePerAdditionalCustodyGroup
+	count := totalNodeBalance / balancePerAdditionalCustodyGroup
 	return min(max(count, validatorCustodyRequirement), numberOfCustodyGroups), nil
 }
 

beacon-chain/execution/BUILD.bazel

@@ -26,7 +26,6 @@ go_library(
         "//testing/spectest:__subpackages__",
     ],
     deps = [
-        "//api/server/structs:go_default_library",
         "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
@@ -102,7 +101,6 @@ go_test(
     data = glob(["testdata/**"]),
     embed = [":go_default_library"],
     deps = [
-        "//api/server/structs:go_default_library",
         "//async/event:go_default_library",
         "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",

beacon-chain/execution/engine_client.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/execution/types"
@@ -110,8 +109,6 @@ const (
 	GetBlobsV1 = "engine_getBlobsV1"
 	// GetBlobsV2 request string for JSON-RPC.
 	GetBlobsV2 = "engine_getBlobsV2"
-	// GetClientVersionV1 is the JSON-RPC method that identifies the execution client.
-	GetClientVersionV1 = "engine_getClientVersionV1"
 	// Defines the seconds before timing out engine endpoints with non-block execution semantics.
 	defaultEngineTimeout = time.Second
 )
@@ -148,7 +145,6 @@ type EngineCaller interface {
 	GetPayload(ctx context.Context, payloadId [8]byte, slot primitives.Slot) (*blocks.GetPayloadResponse, error)
 	ExecutionBlockByHash(ctx context.Context, hash common.Hash, withTxs bool) (*pb.ExecutionBlock, error)
 	GetTerminalBlockHash(ctx context.Context, transitionTime uint64) ([]byte, bool, error)
-	GetClientVersionV1(ctx context.Context) ([]*structs.ClientVersionV1, error)
 }
 
 var ErrEmptyBlockHash = errors.New("Block hash is empty 0x0000...")
@@ -585,39 +581,6 @@ func (s *Service) GetBlobsV2(ctx context.Context, versionedHashes []common.Hash)
 	return result, handleRPCError(err)
 }
 
-func (s *Service) GetClientVersionV1(ctx context.Context) ([]*structs.ClientVersionV1, error) {
-	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetClientVersionV1")
-	defer span.End()
-
-	commit := version.GitCommit()
-	if len(commit) >= 8 {
-		commit = commit[:8]
-	}
-
-	var result []*structs.ClientVersionV1
-	err := s.rpcClient.CallContext(
-		ctx,
-		&result,
-		GetClientVersionV1,
-		structs.ClientVersionV1{
-			Code:    "PM",
-			Name:    "Prysm",
-			Version: version.SemanticVersion(),
-			Commit:  commit,
-		},
-	)
-
-	if err != nil {
-		return nil, handleRPCError(err)
-	}
-
-	if len(result) == 0 {
-		return nil, errors.New("execution client returned no result")
-	}
-
-	return result, nil
-}
-
 // ReconstructFullBlock takes in a blinded beacon block and reconstructs
 // a beacon block with a full execution payload via the engine API.
 func (s *Service) ReconstructFullBlock(

beacon-chain/execution/engine_client_test.go

@@ -13,7 +13,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db/filesystem"
@@ -1000,99 +999,6 @@ func TestClient_HTTP(t *testing.T) {
 		require.NoError(t, err)
 		require.DeepEqual(t, want, resp)
 	})
-	t.Run(GetClientVersionV1, func(t *testing.T) {
-		tests := []struct {
-			name     string
-			want     any
-			resp     []*structs.ClientVersionV1
-			hasError bool
-			errMsg   string
-		}{
-			{
-				name: "happy path",
-				want: []*structs.ClientVersionV1{{
-					Code:    "GE",
-					Name:    "go-ethereum",
-					Version: "1.15.11-stable",
-					Commit:  "36b2371c",
-				}},
-				resp: []*structs.ClientVersionV1{{
-					Code:    "GE",
-					Name:    "go-ethereum",
-					Version: "1.15.11-stable",
-					Commit:  "36b2371c",
-				}},
-			},
-			{
-				name:     "empty response",
-				want:     []*structs.ClientVersionV1{},
-				hasError: true,
-				errMsg:   "execution client returned no result",
-			},
-			{
-				name:     "RPC error",
-				want:     "brokenMsg",
-				hasError: true,
-				errMsg:   "unexpected error in JSON-RPC",
-			},
-		}
-
-		for _, tc := range tests {
-			t.Run(tc.name, func(t *testing.T) {
-				srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-					w.Header().Set("Content-Type", "application/json")
-					defer func() {
-						require.NoError(t, r.Body.Close())
-					}()
-					enc, err := io.ReadAll(r.Body)
-					require.NoError(t, err)
-					jsonRequestString := string(enc)
-
-					// We expect the JSON string RPC request contains the right method name.
-					require.Equal(t, true, strings.Contains(
-						jsonRequestString, GetClientVersionV1,
-					))
-					require.Equal(t, true, strings.Contains(
-						jsonRequestString, "\"code\":\"PM\"",
-					))
-					require.Equal(t, true, strings.Contains(
-						jsonRequestString, "\"name\":\"Prysm\"",
-					))
-					require.Equal(t, true, strings.Contains(
-						jsonRequestString, fmt.Sprintf("\"version\":\"%s\"", version.SemanticVersion()),
-					))
-					require.Equal(t, true, strings.Contains(
-						jsonRequestString, fmt.Sprintf("\"commit\":\"%s\"", version.GitCommit()[:8]),
-					))
-					resp := map[string]any{
-						"jsonrpc": "2.0",
-						"id":      1,
-						"result":  tc.want,
-					}
-					err = json.NewEncoder(w).Encode(resp)
-					require.NoError(t, err)
-				}))
-				defer srv.Close()
-
-				rpcClient, err := rpc.DialHTTP(srv.URL)
-				require.NoError(t, err)
-				defer rpcClient.Close()
-
-				service := &Service{}
-				service.rpcClient = rpcClient
-
-				// We call the RPC method via HTTP and expect a proper result.
-				resp, err := service.GetClientVersionV1(ctx)
-				if tc.hasError {
-					require.NotNil(t, err)
-					require.ErrorContains(t, tc.errMsg, err)
-				} else {
-					require.NoError(t, err)
-				}
-				require.DeepEqual(t, tc.resp, resp)
-			})
-		}
-	})
 }
 
 func TestReconstructFullBellatrixBlock(t *testing.T) {

beacon-chain/execution/testing/BUILD.bazel

@@ -13,7 +13,6 @@ go_library(
         "//visibility:public",
     ],
     deps = [
-        "//api/server/structs:go_default_library",
         "//async/event:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/execution/types:go_default_library",

beacon-chain/execution/testing/mock_engine_client.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"math/big"
 
-	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
@@ -43,8 +42,6 @@ type EngineClient struct {
 	ErrorBlobSidecars           error
 	DataColumnSidecars          []blocks.VerifiedRODataColumn
 	ErrorDataColumnSidecars     error
-	ClientVersion               []*structs.ClientVersionV1
-	ErrorClientVersion          error
 }
 
 // NewPayload --
@@ -176,8 +173,3 @@ func (e *EngineClient) GetTerminalBlockHash(ctx context.Context, transitionTime
 		blk = parentBlk
 	}
 }
-
-// GetClientVersionV1 --
-func (e *EngineClient) GetClientVersionV1(context.Context) ([]*structs.ClientVersionV1, error) {
-	return e.ClientVersion, e.ErrorClientVersion
-}

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/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,29 @@ 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(pe interfaces.ROExecutionPayloadEnvelope) error {
+	if pe.IsNil() {
+		return errors.New("cannot insert nil payload")
+	}
+	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
+	return nil
+}

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

@@ -0,0 +1,299 @@
+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(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(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(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)
+
+	root := indexToHash(99)
+	pe, err := prepareGloasForkchoicePayload(root)
+	require.NoError(t, err)
+
+	err = f.InsertPayload(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(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(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/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/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,6 +49,11 @@ type BlockProcessor interface {
 	InsertChain(context.Context, []*forkchoicetypes.BlockAndCheckpoints) error
 }
 
+// PayloadProcessor processes a payload envelope
+type PayloadProcessor interface {
+	InsertPayload(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)

beacon-chain/rpc/endpoints.go

@@ -405,7 +405,6 @@ func (s *Service) nodeEndpoints() []endpoint {
 		MetadataProvider:          s.cfg.MetadataProvider,
 		HeadFetcher:               s.cfg.HeadFetcher,
 		ExecutionChainInfoFetcher: s.cfg.ExecutionChainInfoFetcher,
-		ExecutionEngineCaller:     s.cfg.ExecutionEngineCaller,
 	}
 
 	const namespace = "node"
@@ -470,16 +469,6 @@ func (s *Service) nodeEndpoints() []endpoint {
 			handler: server.GetVersion,
 			methods: []string{http.MethodGet},
 		},
-		{
-			template: "/eth/v2/node/version",
-			name:     namespace + ".GetVersionV2",
-			middleware: []middleware.Middleware{
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
-				middleware.AcceptEncodingHeaderHandler(),
-			},
-			handler: server.GetVersionV2,
-			methods: []string{http.MethodGet},
-		},
 		{
 			template: "/eth/v1/node/health",
 			name:     namespace + ".GetHealth",

beacon-chain/rpc/endpoints_test.go

@@ -86,7 +86,6 @@ func Test_endpoints(t *testing.T) {
 		"/eth/v1/node/peers/{peer_id}": {http.MethodGet},
 		"/eth/v1/node/peer_count":      {http.MethodGet},
 		"/eth/v1/node/version":         {http.MethodGet},
-		"/eth/v2/node/version":         {http.MethodGet},
 		"/eth/v1/node/syncing":         {http.MethodGet},
 		"/eth/v1/node/health":          {http.MethodGet},
 	}

beacon-chain/rpc/eth/node/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "handlers.go",
         "handlers_peers.go",
-        "log.go",
         "server.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/eth/node",
@@ -31,7 +30,6 @@ go_library(
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
     ],
 )
@@ -46,7 +44,6 @@ go_test(
     deps = [
         "//api/server/structs:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
-        "//beacon-chain/execution/testing:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/p2p/peers:go_default_library",
         "//beacon-chain/p2p/testing:go_default_library",

beacon-chain/rpc/eth/node/handlers.go

@@ -103,8 +103,6 @@ func (s *Server) GetIdentity(w http.ResponseWriter, r *http.Request) {
 
 // GetVersion requests that the beacon node identify information about its implementation in a
 // format similar to a HTTP User-Agent field.
-//
-// Deprecated: in favour of GetVersionV2.
 func (*Server) GetVersion(w http.ResponseWriter, r *http.Request) {
 	_, span := trace.StartSpan(r.Context(), "node.GetVersion")
 	defer span.End()
@@ -118,38 +116,6 @@ func (*Server) GetVersion(w http.ResponseWriter, r *http.Request) {
 	httputil.WriteJson(w, resp)
 }
 
-// GetVersionV2 Retrieves structured information about the version of the beacon node and its attached
-// execution client in the same format as used on the Engine API
-func (s *Server) GetVersionV2(w http.ResponseWriter, r *http.Request) {
-	ctx, span := trace.StartSpan(r.Context(), "node.GetVersionV2")
-	defer span.End()
-
-	var elData *structs.ClientVersionV1
-	elDataList, err := s.ExecutionEngineCaller.GetClientVersionV1(ctx)
-	if err != nil {
-		log.WithError(err).WithField("endpoint", "GetVersionV2").Debug("Could not get execution client version")
-	} else if len(elDataList) > 0 {
-		elData = elDataList[0]
-	}
-
-	commit := version.GitCommit()
-	if len(commit) >= 8 {
-		commit = commit[:8]
-	}
-	resp := &structs.GetVersionV2Response{
-		Data: &structs.VersionV2{
-			BeaconNode: &structs.ClientVersionV1{
-				Code:    "PM",
-				Name:    "Prysm",
-				Version: version.SemanticVersion(),
-				Commit:  commit,
-			},
-			ExecutionClient: elData,
-		},
-	}
-	httputil.WriteJson(w, resp)
-}
-
 // GetHealth returns node health status in http status codes. Useful for load balancers.
 func (s *Server) GetHealth(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "node.GetHealth")

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

@@ -12,7 +12,6 @@ import (
 	"github.com/OffchainLabs/go-bitfield"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	mock "github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/testing"
-	mockengine "github.com/OffchainLabs/prysm/v7/beacon-chain/execution/testing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
 	mockp2p "github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/testutil"
@@ -91,75 +90,6 @@ func TestGetVersion(t *testing.T) {
 	assert.StringContains(t, arch, resp.Data.Version)
 }
 
-func TestGetVersionV2(t *testing.T) {
-	t.Run("happy path", func(t *testing.T) {
-		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/node/version", nil)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s := &Server{
-			ExecutionEngineCaller: &mockengine.EngineClient{
-				ClientVersion: []*structs.ClientVersionV1{{
-					Code:    "EL",
-					Name:    "ExecutionClient",
-					Version: "v1.0.0",
-					Commit:  "abcdef12",
-				}},
-			},
-		}
-		s.GetVersionV2(writer, request)
-		require.Equal(t, http.StatusOK, writer.Code)
-
-		resp := &structs.GetVersionV2Response{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		require.NotNil(t, resp)
-		require.NotNil(t, resp.Data)
-		require.NotNil(t, resp.Data.BeaconNode)
-		require.NotNil(t, resp.Data.ExecutionClient)
-		require.Equal(t, "EL", resp.Data.ExecutionClient.Code)
-		require.Equal(t, "ExecutionClient", resp.Data.ExecutionClient.Name)
-		require.Equal(t, "v1.0.0", resp.Data.ExecutionClient.Version)
-		require.Equal(t, "abcdef12", resp.Data.ExecutionClient.Commit)
-		require.Equal(t, "PM", resp.Data.BeaconNode.Code)
-		require.Equal(t, "Prysm", resp.Data.BeaconNode.Name)
-		require.Equal(t, version.SemanticVersion(), resp.Data.BeaconNode.Version)
-		require.Equal(t, true, len(resp.Data.BeaconNode.Commit) <= 8)
-	})
-
-	t.Run("unhappy path", func(t *testing.T) {
-		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/node/version", nil)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s := &Server{
-			ExecutionEngineCaller: &mockengine.EngineClient{
-				ClientVersion:      nil,
-				ErrorClientVersion: fmt.Errorf("error"),
-			},
-		}
-		s.GetVersionV2(writer, request)
-		require.Equal(t, http.StatusOK, writer.Code)
-
-		resp := &structs.GetVersionV2Response{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		require.NotNil(t, resp)
-		require.NotNil(t, resp.Data)
-		require.NotNil(t, resp.Data.BeaconNode)
-		require.Equal(t, true, resp.Data.ExecutionClient == nil)
-
-		// make sure there is no 'execution_client' field
-		var payload map[string]any
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), &payload))
-		data, ok := payload["data"].(map[string]any)
-		require.Equal(t, true, ok)
-		_, found := data["beacon_node"]
-		require.Equal(t, true, found)
-		_, found = data["execution_client"]
-		require.Equal(t, false, found)
-	})
-
-}
-
 func TestGetHealth(t *testing.T) {
 	checker := &syncmock.Sync{}
 	optimisticFetcher := &mock.ChainService{Optimistic: false}

beacon-chain/rpc/eth/node/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package node
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/rpc/eth/node")

beacon-chain/rpc/eth/node/server.go

@@ -26,5 +26,4 @@ type Server struct {
 	GenesisTimeFetcher        blockchain.TimeFetcher
 	HeadFetcher               blockchain.HeadFetcher
 	ExecutionChainInfoFetcher execution.ChainInfoFetcher
-	ExecutionEngineCaller     execution.EngineCaller
 }

beacon-chain/state/interfaces.go

@@ -152,7 +152,6 @@ 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/state-native/getters_validator.go

@@ -8,7 +8,6 @@ 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.
@@ -81,25 +80,6 @@ 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,7 +5,6 @@ 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"
 )
 
@@ -15,8 +14,6 @@ type StateManager struct {
 	StatesBySlot map[primitives.Slot]state.BeaconState
 }
 
-var _ stategen.StateManager = (*StateManager)(nil)
-
 // NewService --
 func NewService() *StateManager {
 	return &StateManager{
@@ -104,8 +101,3 @@ 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,13 +27,6 @@ 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 {
@@ -50,7 +43,6 @@ 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.
@@ -209,8 +201,3 @@ 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/custody.go

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

beacon-chain/sync/validate_beacon_attestation.go

@@ -268,23 +268,10 @@ func (s *Service) validateCommitteeIndexAndCount(
 	a eth.Att,
 	bs state.ReadOnlyBeaconState,
 ) (primitives.CommitteeIndex, uint64, pubsub.ValidationResult, error) {
-	// 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")
-			}
-		}
+	// - [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")
 	}
-
 	valCount, err := helpers.ActiveValidatorCount(ctx, bs, slots.ToEpoch(a.GetData().Slot))
 	if err != nil {
 		return 0, 0, pubsub.ValidationIgnore, err
@@ -369,29 +356,6 @@ 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,75 +684,3 @@ 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)
-			}
-		})
-	}
-}

changelog/bastin_get-version-v2.md

@@ -1,3 +0,0 @@
-### Added
-
-- New beacon API endpoint `eth/v2/node/version`.

changelog/kasey_copy-free-balance-lookup.md

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

changelog/potuz_gloas_forkchoice_insert_payload.md

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

changelog/potuz_prefer_cached_over_head.md

@@ -1,2 +0,0 @@
-### Changed
-- Prefer the cached epoch transition states and the NSC ones over head state for attestation verification. 

changelog/terence_gloas-attestation-validation.md

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

changelog/tt_apply_execution_payload.md

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

runtime/version/version.go

@@ -34,17 +34,8 @@ func SemanticVersion() string {
 	return gitTag
 }
 
-// GitCommit returns the current build commit hash.
-func GitCommit() string {
-	return resolvedGitCommit()
-}
-
 // BuildData returns the git tag and commit of the current build.
 func BuildData() string {
-	return fmt.Sprintf("Prysm/%s/%s", gitTag, resolvedGitCommit())
-}
-
-func resolvedGitCommit() string {
 	// if doing a local build, these values are not interpolated
 	if gitCommit == "{STABLE_GIT_COMMIT}" {
 		commit, err := exec.Command("git", "rev-parse", "HEAD").Output()
@@ -54,7 +45,7 @@ func resolvedGitCommit() string {
 			gitCommit = strings.TrimRight(string(commit), "\r\n")
 		}
 	}
-	return gitCommit
+	return fmt.Sprintf("Prysm/%s/%s", gitTag, gitCommit)
 }
 
 // GetCommitPrefix returns the first 4 characters of the git commit.

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

@@ -12,7 +12,6 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/common/forkchoice",
     visibility = ["//testing/spectest:__subpackages__"],
     deps = [
-        "//api/server/structs:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",

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

@@ -5,7 +5,6 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	mock "github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/testing"
@@ -142,7 +141,3 @@ func (m *engineMock) ExecutionBlockByHash(_ context.Context, hash common.Hash, _
 func (m *engineMock) GetTerminalBlockHash(context.Context, uint64) ([]byte, bool, error) {
 	return nil, false, nil
 }
-
-func (m *engineMock) GetClientVersionV1(context.Context) ([]*structs.ClientVersionV1, error) {
-	return nil, nil
-}