test

<!-- Thanks for sending a PR! Before submitting:

1. If this is your first PR, check out our contribution guide here
https://docs.prylabs.network/docs/contribute/contribution-guidelines
You will then need to sign our Contributor License Agreement (CLA),
which will show up as a comment from a bot in this pull request after
you open it. We cannot review code without a signed CLA.
2. Please file an associated tracking issue if this pull request is
non-trivial and requires context for our team to understand. All
features and most bug fixes should have
an associated issue with a design discussed and decided upon. Small bug
   fixes and documentation improvements don't need issues.
3. New features and bug fixes must have tests. Documentation may need to
be updated. If you're unsure what to update, send the PR, and we'll
discuss
   in review.
4. Note that PRs updating dependencies and new Go versions are not
accepted.
   Please file an issue instead.
5. A changelog entry is required for user facing issues.
-->

**What type of PR is this?**

Other

**What does this PR do? Why is it needed?**


[/eth/v1/beacon/blocks/{block_id}/root](https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlockRoot)
updated logic so that it uses the blocker lookup instead of mostly
duplicated logic

- The new implementation returns an error if no canonical block exists
at a slot, while the old one would return a
   non-canonical block's root
- adds justified as an option for block id

**Which issues(s) does this PR fix?**

Fixes #

**Other notes for review**

**Acknowledgements**

- [x] I have read
[CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md).
- [x] I have included a uniquely named [changelog fragment
file](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md#maintaining-changelogmd).
- [x] I have added a description with sufficient context for reviewers
to understand this PR.
- [x] I have tested that my changes work as expected and I added a
testing plan to the PR description (if applicable).

---------

Co-authored-by: Radosław Kapka <rkapka@wp.pl>

api/client/BUILD.bazel

@@ -10,7 +10,10 @@ go_library(
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/api/client",
     visibility = ["//visibility:public"],
-    deps = ["@com_github_pkg_errors//:go_default_library"],
+    deps = [
+        "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
 )
 
 go_test(

api/client/client.go

@@ -8,6 +8,7 @@ import (
 	"net/url"
 
 	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
 )
 
 const (
@@ -28,6 +29,7 @@ type Client struct {
 // `host` is the base host + port used to construct request urls. This value can be
 // a URL string, or NewClient will assume an http endpoint if just `host:port` is used.
 func NewClient(host string, opts ...ClientOpt) (*Client, error) {
+	log.Info("hi")
 	u, err := urlForHost(host)
 	if err != nil {
 		return nil, err

beacon-chain/core/gloas/BUILD.bazel

@@ -4,10 +4,8 @@ go_library(
     name = "go_default_library",
     srcs = [
         "bid.go",
-        "builder.go",
         "pending_payment.go",
         "proposer_slashing.go",
-        "withdrawal.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
     visibility = ["//visibility:public"],
@@ -23,7 +21,6 @@ go_library(
         "//crypto/bls:go_default_library",
         "//crypto/bls/common:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],

beacon-chain/core/gloas/builder.go

@@ -1,46 +0,0 @@
-package gloas
-
-import (
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-)
-
-// IsBuilderIndex returns true when the BuilderIndex flag is set on a validator index.
-// Spec v1.6.1 (pseudocode):
-// def is_builder_index(validator_index: ValidatorIndex) -> bool:
-//
-//	return (validator_index & BUILDER_INDEX_FLAG) != 0
-func IsBuilderIndex(validatorIndex primitives.ValidatorIndex) bool {
-	return uint64(validatorIndex)&params.BeaconConfig().BuilderIndexFlag != 0
-}
-
-// ConvertValidatorIndexToBuilderIndex strips the builder flag from a validator index.
-// Spec v1.6.1 (pseudocode):
-// def convert_validator_index_to_builder_index(validator_index: ValidatorIndex) -> BuilderIndex:
-//
-//	return BuilderIndex(validator_index & ~BUILDER_INDEX_FLAG)
-func ConvertValidatorIndexToBuilderIndex(validatorIndex primitives.ValidatorIndex) primitives.BuilderIndex {
-	return primitives.BuilderIndex(uint64(validatorIndex) & ^params.BeaconConfig().BuilderIndexFlag)
-}
-
-// ConvertBuilderIndexToValidatorIndex sets the builder flag on a builder index.
-// Spec v1.6.1 (pseudocode):
-// def convert_builder_index_to_validator_index(builder_index: BuilderIndex) -> ValidatorIndex:
-//
-//	return ValidatorIndex(builder_index | BUILDER_INDEX_FLAG)
-func ConvertBuilderIndexToValidatorIndex(builderIndex primitives.BuilderIndex) primitives.ValidatorIndex {
-	return primitives.ValidatorIndex(uint64(builderIndex) | params.BeaconConfig().BuilderIndexFlag)
-}
-
-// IsBuilderWithdrawalCredential returns true when the builder withdrawal prefix is set.
-// Spec v1.6.1 (pseudocode):
-// def is_builder_withdrawal_credential(withdrawal_credentials: Bytes32) -> bool:
-//
-//	return withdrawal_credentials[:1] == BUILDER_WITHDRAWAL_PREFIX
-func IsBuilderWithdrawalCredential(withdrawalCredentials []byte) bool {
-	if len(withdrawalCredentials) == 0 {
-		return false
-	}
-	return withdrawalCredentials[0] == params.BeaconConfig().BuilderWithdrawalPrefixByte
-}
-

beacon-chain/core/gloas/withdrawal.go

@@ -1,89 +0,0 @@
-package gloas
-
-import (
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/pkg/errors"
-)
-
-func ProcessWithdrawals(st state.BeaconState) error {
-	if st.Version() < version.Gloas {
-		return errors.New("Process withdrawals gloas cant be called in version xyz")
-	}
-
-	full, err := st.IsParentBlockFull()
-	if err != nil {
-		return errors.Wrap(err, "could not get parent block full status")
-	}
-	if !full {
-		return nil
-	}
-
-	expectedWithdrawals, processedBuilderWithdrawalsCount, processedPartialWithdrawalsCount, nextWithdrawalBuilderIndex, err := st.ExpectedWithdrawalsGloas()
-	if err != nil {
-		return errors.Wrap(err, "could not get expected withdrawals")
-	}
-
-	for _, withdrawal := range expectedWithdrawals {
-		if IsBuilderIndex(withdrawal.ValidatorIndex) {
-			builderIndex := ConvertValidatorIndexToBuilderIndex(withdrawal.ValidatorIndex)
-			err := st.DecreaseBuilderBalance(builderIndex, withdrawal.Amount)
-			if err != nil {
-				return errors.Wrap(err, "could not decrease builder balance")
-			}
-		} else {
-			err := helpers.DecreaseBalance(st, withdrawal.ValidatorIndex, withdrawal.Amount)
-			if err != nil {
-				return errors.Wrap(err, "could not decrease balance")
-			}
-		}
-	}
-
-	err = st.SetPayloadExpectedWithdrawals(expectedWithdrawals)
-	if err != nil {
-		return errors.Wrap(err, "could not set payload expected withdrawals")
-	}
-	err = st.DequeueBuilderPendingWithdrawals(processedBuilderWithdrawalsCount)
-	if err != nil {
-		return fmt.Errorf("unable to dequeue builder pending withdrawals from state: %w", err)
-	}
-	err = st.SetNextWithdrawalBuilderIndex(nextWithdrawalBuilderIndex)
-	if err != nil {
-		return errors.Wrap(err, "could not set next withdrawal builder index")
-	}
-
-	if err := st.DequeuePendingPartialWithdrawals(processedPartialWithdrawalsCount); err != nil {
-		return fmt.Errorf("unable to dequeue partial withdrawals from state: %w", err)
-	}
-
-	if len(expectedWithdrawals) > 0 {
-		if err := st.SetNextWithdrawalIndex(expectedWithdrawals[len(expectedWithdrawals)-1].Index + 1); err != nil {
-			return errors.Wrap(err, "could not set next withdrawal index")
-		}
-	}
-
-	var nextValidatorIndex primitives.ValidatorIndex
-	if uint64(len(expectedWithdrawals)) < params.BeaconConfig().MaxWithdrawalsPerPayload {
-		nextValidatorIndex, err = st.NextWithdrawalValidatorIndex()
-		if err != nil {
-			return errors.Wrap(err, "could not get next withdrawal validator index")
-		}
-		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
-		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
-	} else {
-		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1
-		if nextValidatorIndex == primitives.ValidatorIndex(st.NumValidators()) {
-			nextValidatorIndex = 0
-		}
-	}
-	if err := st.SetNextWithdrawalValidatorIndex(nextValidatorIndex); err != nil {
-		return errors.Wrap(err, "could not set next withdrawal validator index")
-	}
-
-	return nil
-}

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

@@ -8,7 +8,6 @@ import (
 	"io"
 	"net/http"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v7/api"
@@ -26,7 +25,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	"github.com/OffchainLabs/prysm/v7/network/httputil"
 	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
@@ -1044,112 +1042,27 @@ func (s *Server) GetBlockRoot(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlockRoot")
 	defer span.End()
 
-	var err error
-	var root []byte
 	blockID := r.PathValue("block_id")
 	if blockID == "" {
 		httputil.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
 		return
 	}
-	switch blockID {
-	case "head":
-		root, err = s.ChainInfoFetcher.HeadRoot(ctx)
-		if err != nil {
-			httputil.HandleError(w, "Could not retrieve head root: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		if root == nil {
-			httputil.HandleError(w, "No head root was found", http.StatusNotFound)
-			return
-		}
-	case "finalized":
-		finalized := s.ChainInfoFetcher.FinalizedCheckpt()
-		root = finalized.Root
-	case "genesis":
-		blk, err := s.BeaconDB.GenesisBlock(ctx)
-		if err != nil {
-			httputil.HandleError(w, "Could not retrieve genesis block: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		if err := blocks.BeaconBlockIsNil(blk); err != nil {
-			httputil.HandleError(w, "Could not find genesis block: "+err.Error(), http.StatusNotFound)
-			return
-		}
-		blkRoot, err := blk.Block().HashTreeRoot()
-		if err != nil {
-			httputil.HandleError(w, "Could not hash genesis block: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		root = blkRoot[:]
-	default:
-		isHex := strings.HasPrefix(blockID, "0x")
-		if isHex {
-			blockIDBytes, err := hexutil.Decode(blockID)
-			if err != nil {
-				httputil.HandleError(w, "Could not decode block ID into bytes: "+err.Error(), http.StatusBadRequest)
-				return
-			}
-			if len(blockIDBytes) != fieldparams.RootLength {
-				httputil.HandleError(w, fmt.Sprintf("Block ID has length %d instead of %d", len(blockIDBytes), fieldparams.RootLength), http.StatusBadRequest)
-				return
-			}
-			blockID32 := bytesutil.ToBytes32(blockIDBytes)
-			blk, err := s.BeaconDB.Block(ctx, blockID32)
-			if err != nil {
-				httputil.HandleError(w, fmt.Sprintf("Could not retrieve block for block root %#x: %v", blockID, err), http.StatusInternalServerError)
-				return
-			}
-			if err := blocks.BeaconBlockIsNil(blk); err != nil {
-				httputil.HandleError(w, "Could not find block: "+err.Error(), http.StatusNotFound)
-				return
-			}
-			root = blockIDBytes
-		} else {
-			slot, err := strconv.ParseUint(blockID, 10, 64)
-			if err != nil {
-				httputil.HandleError(w, "Could not parse block ID: "+err.Error(), http.StatusBadRequest)
-				return
-			}
-			hasRoots, roots, err := s.BeaconDB.BlockRootsBySlot(ctx, primitives.Slot(slot))
-			if err != nil {
-				httputil.HandleError(w, fmt.Sprintf("Could not retrieve blocks for slot %d: %v", slot, err), http.StatusInternalServerError)
-				return
-			}
-
-			if !hasRoots {
-				httputil.HandleError(w, "Could not find any blocks with given slot", http.StatusNotFound)
-				return
-			}
-			root = roots[0][:]
-			if len(roots) == 1 {
-				break
-			}
-			for _, blockRoot := range roots {
-				canonical, err := s.ChainInfoFetcher.IsCanonical(ctx, blockRoot)
-				if err != nil {
-					httputil.HandleError(w, "Could not determine if block root is canonical: "+err.Error(), http.StatusInternalServerError)
-					return
-				}
-				if canonical {
-					root = blockRoot[:]
-					break
-				}
-			}
-		}
+	root, err := s.Blocker.BlockRoot(ctx, []byte(blockID))
+	if !shared.WriteBlockRootFetchError(w, err) {
+		return
 	}
 
-	b32Root := bytesutil.ToBytes32(root)
-	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, b32Root)
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
 	if err != nil {
 		httputil.HandleError(w, "Could not check if block is optimistic: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
 	response := &structs.BlockRootResponse{
 		Data: &structs.BlockRoot{
-			Root: hexutil.Encode(root),
+			Root: hexutil.Encode(root[:]),
 		},
 		ExecutionOptimistic: isOptimistic,
-		Finalized:           s.FinalizationFetcher.IsFinalized(ctx, b32Root),
+		Finalized:           s.FinalizationFetcher.IsFinalized(ctx, root),
 	}
 	httputil.WriteJson(w, response)
 }

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

@@ -2509,6 +2509,10 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			HeadFetcher:           mockChainFetcher,
 			OptimisticModeFetcher: mockChainFetcher,
 			FinalizationFetcher:   mockChainFetcher,
+			Blocker: &lookup.BeaconDbBlocker{
+				BeaconDB:         beaconDB,
+				ChainInfoFetcher: mockChainFetcher,
+			},
 		}
 
 		root, err := genBlk.Block.HashTreeRoot()
@@ -2524,7 +2528,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			{
 				name:     "bad formatting",
 				blockID:  map[string]string{"block_id": "3bad0"},
-				wantErr:  "Could not parse block ID",
+				wantErr:  "Invalid block ID",
 				wantCode: http.StatusBadRequest,
 			},
 			{
@@ -2572,7 +2576,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			{
 				name:     "non-existent root",
 				blockID:  map[string]string{"block_id": hexutil.Encode(bytesutil.PadTo([]byte("hi there"), 32))},
-				wantErr:  "Could not find block",
+				wantErr:  "Block not found",
 				wantCode: http.StatusNotFound,
 			},
 			{
@@ -2585,7 +2589,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			{
 				name:     "no block",
 				blockID:  map[string]string{"block_id": "105"},
-				wantErr:  "Could not find any blocks with given slot",
+				wantErr:  "Block not found",
 				wantCode: http.StatusNotFound,
 			},
 		}
@@ -2633,6 +2637,10 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			HeadFetcher:           mockChainFetcher,
 			OptimisticModeFetcher: mockChainFetcher,
 			FinalizationFetcher:   mockChainFetcher,
+			Blocker: &lookup.BeaconDbBlocker{
+				BeaconDB:         beaconDB,
+				ChainInfoFetcher: mockChainFetcher,
+			},
 		}
 
 		request := httptest.NewRequest(http.MethodGet, url, nil)
@@ -2668,6 +2676,10 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			HeadFetcher:           mockChainFetcher,
 			OptimisticModeFetcher: mockChainFetcher,
 			FinalizationFetcher:   mockChainFetcher,
+			Blocker: &lookup.BeaconDbBlocker{
+				BeaconDB:         beaconDB,
+				ChainInfoFetcher: mockChainFetcher,
+			},
 		}
 		t.Run("true", func(t *testing.T) {
 			request := httptest.NewRequest(http.MethodGet, url, nil)

beacon-chain/rpc/eth/shared/errors.go

@@ -26,21 +26,30 @@ func WriteStateFetchError(w http.ResponseWriter, err error) {
 	httputil.HandleError(w, "Could not get state: "+err.Error(), http.StatusInternalServerError)
 }
 
-// WriteBlockFetchError writes an appropriate error based on the supplied argument.
-// The argument error should be a result of fetching block.
-func WriteBlockFetchError(w http.ResponseWriter, blk interfaces.ReadOnlySignedBeaconBlock, err error) bool {
+// writeBlockIdError handles common block ID lookup errors.
+// Returns true if an error was handled and written to the response, false if no error.
+func writeBlockIdError(w http.ResponseWriter, err error, fallbackMsg string) bool {
+	if err == nil {
+		return false
+	}
 	var blockNotFoundErr *lookup.BlockNotFoundError
 	if errors.As(err, &blockNotFoundErr) {
 		httputil.HandleError(w, "Block not found: "+blockNotFoundErr.Error(), http.StatusNotFound)
-		return false
+		return true
 	}
 	var invalidBlockIdErr *lookup.BlockIdParseError
 	if errors.As(err, &invalidBlockIdErr) {
 		httputil.HandleError(w, "Invalid block ID: "+invalidBlockIdErr.Error(), http.StatusBadRequest)
-		return false
+		return true
 	}
-	if err != nil {
-		httputil.HandleError(w, "Could not get block from block ID: "+err.Error(), http.StatusInternalServerError)
+	httputil.HandleError(w, fallbackMsg+": "+err.Error(), http.StatusInternalServerError)
+	return true
+}
+
+// WriteBlockFetchError writes an appropriate error based on the supplied argument.
+// The argument error should be a result of fetching block.
+func WriteBlockFetchError(w http.ResponseWriter, blk interfaces.ReadOnlySignedBeaconBlock, err error) bool {
+	if writeBlockIdError(w, err, "Could not get block from block ID") {
 		return false
 	}
 	if err = blocks.BeaconBlockIsNil(blk); err != nil {
@@ -49,3 +58,10 @@ func WriteBlockFetchError(w http.ResponseWriter, blk interfaces.ReadOnlySignedBe
 	}
 	return true
 }
+
+// WriteBlockRootFetchError writes an appropriate error based on the supplied argument.
+// The argument error should be a result of fetching block root.
+// Returns true if no error occurred, false otherwise.
+func WriteBlockRootFetchError(w http.ResponseWriter, err error) bool {
+	return !writeBlockIdError(w, err, "Could not get block root from block ID")
+}

beacon-chain/rpc/eth/shared/errors_test.go

@@ -105,3 +105,59 @@ func TestWriteBlockFetchError(t *testing.T) {
 		})
 	}
 }
+
+// TestWriteBlockRootFetchError tests the WriteBlockRootFetchError function
+// to ensure that the correct error message and code are written to the response
+// and that the function returns the correct boolean value.
+func TestWriteBlockRootFetchError(t *testing.T) {
+	cases := []struct {
+		name            string
+		err             error
+		expectedMessage string
+		expectedCode    int
+		expectedReturn  bool
+	}{
+		{
+			name:           "Nil error should return true",
+			err:            nil,
+			expectedReturn: true,
+		},
+		{
+			name:            "BlockNotFoundError should return 404",
+			err:             lookup.NewBlockNotFoundError("block not found at slot 123"),
+			expectedMessage: "Block not found",
+			expectedCode:    http.StatusNotFound,
+			expectedReturn:  false,
+		},
+		{
+			name:            "BlockIdParseError should return 400",
+			err:             &lookup.BlockIdParseError{},
+			expectedMessage: "Invalid block ID",
+			expectedCode:    http.StatusBadRequest,
+			expectedReturn:  false,
+		},
+		{
+			name:            "Generic error should return 500",
+			err:             errors.New("database connection failed"),
+			expectedMessage: "Could not get block root from block ID",
+			expectedCode:    http.StatusInternalServerError,
+			expectedReturn:  false,
+		},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			writer := httptest.NewRecorder()
+			result := WriteBlockRootFetchError(writer, c.err)
+
+			assert.Equal(t, c.expectedReturn, result, "incorrect return value")
+			if !c.expectedReturn {
+				assert.Equal(t, c.expectedCode, writer.Code, "incorrect status code")
+				assert.StringContains(t, c.expectedMessage, writer.Body.String(), "incorrect error message")
+
+				e := &httputil.DefaultJsonError{}
+				assert.NoError(t, json.Unmarshal(writer.Body.Bytes(), e), "failed to unmarshal response")
+			}
+		})
+	}
+}

beacon-chain/rpc/lookup/blocker.go

@@ -60,6 +60,7 @@ func (e BlockIdParseError) Error() string {
 // Blocker is responsible for retrieving blocks.
 type Blocker interface {
 	Block(ctx context.Context, id []byte) (interfaces.ReadOnlySignedBeaconBlock, error)
+	BlockRoot(ctx context.Context, id []byte) ([fieldparams.RootLength]byte, error)
 	BlobSidecars(ctx context.Context, id string, opts ...options.BlobsOption) ([]*blocks.VerifiedROBlob, *core.RpcError)
 	Blobs(ctx context.Context, id string, opts ...options.BlobsOption) ([][]byte, *core.RpcError)
 	DataColumns(ctx context.Context, id string, indices []int) ([]blocks.VerifiedRODataColumn, *core.RpcError)
@@ -225,6 +226,18 @@ func (p *BeaconDbBlocker) Block(ctx context.Context, id []byte) (interfaces.Read
 	return blk, nil
 }
 
+// BlockRoot returns the block root for a given identifier. The identifier can be one of:
+//   - "head" (canonical head in node's view)
+//   - "genesis"
+//   - "finalized"
+//   - "justified"
+//   - <slot>
+//   - <hex encoded block root with '0x' prefix>
+func (p *BeaconDbBlocker) BlockRoot(ctx context.Context, id []byte) ([fieldparams.RootLength]byte, error) {
+	root, _, err := p.resolveBlockID(ctx, string(id))
+	return root, err
+}
+
 // blobsContext holds common information needed for blob retrieval
 type blobsContext struct {
 	root        [fieldparams.RootLength]byte

beacon-chain/rpc/lookup/blocker_test.go

@@ -168,6 +168,111 @@ func TestGetBlock(t *testing.T) {
 	}
 }
 
+func TestBlockRoot(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+	ctx := t.Context()
+
+	genBlk, blkContainers := testutil.FillDBWithBlocks(ctx, t, beaconDB)
+	canonicalRoots := make(map[[32]byte]bool)
+
+	for _, bContr := range blkContainers {
+		canonicalRoots[bytesutil.ToBytes32(bContr.BlockRoot)] = true
+	}
+	headBlock := blkContainers[len(blkContainers)-1]
+
+	wsb, err := blocks.NewSignedBeaconBlock(headBlock.Block.(*ethpb.BeaconBlockContainer_Phase0Block).Phase0Block)
+	require.NoError(t, err)
+
+	fetcher := &BeaconDbBlocker{
+		BeaconDB: beaconDB,
+		ChainInfoFetcher: &mockChain.ChainService{
+			DB:                         beaconDB,
+			Block:                      wsb,
+			Root:                       headBlock.BlockRoot,
+			FinalizedCheckPoint:        &ethpb.Checkpoint{Root: blkContainers[64].BlockRoot},
+			CurrentJustifiedCheckPoint: &ethpb.Checkpoint{Root: blkContainers[32].BlockRoot},
+			CanonicalRoots:             canonicalRoots,
+		},
+	}
+
+	genesisRoot, err := genBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	tests := []struct {
+		name    string
+		blockID []byte
+		want    [32]byte
+		wantErr bool
+	}{
+		{
+			name:    "slot",
+			blockID: []byte("30"),
+			want:    bytesutil.ToBytes32(blkContainers[30].BlockRoot),
+		},
+		{
+			name:    "bad formatting",
+			blockID: []byte("3bad0"),
+			wantErr: true,
+		},
+		{
+			name:    "head",
+			blockID: []byte("head"),
+			want:    bytesutil.ToBytes32(headBlock.BlockRoot),
+		},
+		{
+			name:    "finalized",
+			blockID: []byte("finalized"),
+			want:    bytesutil.ToBytes32(blkContainers[64].BlockRoot),
+		},
+		{
+			name:    "justified",
+			blockID: []byte("justified"),
+			want:    bytesutil.ToBytes32(blkContainers[32].BlockRoot),
+		},
+		{
+			name:    "genesis",
+			blockID: []byte("genesis"),
+			want:    genesisRoot,
+		},
+		{
+			name:    "genesis root",
+			blockID: genesisRoot[:],
+			want:    genesisRoot,
+		},
+		{
+			name:    "root",
+			blockID: blkContainers[20].BlockRoot,
+			want:    bytesutil.ToBytes32(blkContainers[20].BlockRoot),
+		},
+		{
+			name:    "hex root",
+			blockID: []byte(hexutil.Encode(blkContainers[20].BlockRoot)),
+			want:    bytesutil.ToBytes32(blkContainers[20].BlockRoot),
+		},
+		{
+			name:    "non-existent root",
+			blockID: bytesutil.PadTo([]byte("hi there"), 32),
+			wantErr: true,
+		},
+		{
+			name:    "no block at slot",
+			blockID: []byte("105"),
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := fetcher.BlockRoot(ctx, tt.blockID)
+			if tt.wantErr {
+				assert.NotEqual(t, err, nil, "no error has been returned")
+				return
+			}
+			require.NoError(t, err)
+			assert.DeepEqual(t, tt.want, result)
+		})
+	}
+}
+
 func TestBlobsErrorHandling(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	cfg := params.BeaconConfig().Copy()

beacon-chain/rpc/testutil/mock_blocker.go

@@ -15,6 +15,7 @@ import (
 // MockBlocker is a fake implementation of lookup.Blocker.
 type MockBlocker struct {
 	BlockToReturn            interfaces.ReadOnlySignedBeaconBlock
+	RootToReturn             [32]byte
 	ErrorToReturn            error
 	SlotBlockMap             map[primitives.Slot]interfaces.ReadOnlySignedBeaconBlock
 	RootBlockMap             map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
@@ -39,6 +40,14 @@ func (m *MockBlocker) Block(_ context.Context, b []byte) (interfaces.ReadOnlySig
 	return m.SlotBlockMap[primitives.Slot(slotNumber)], nil
 }
 
+// BlockRoot --
+func (m *MockBlocker) BlockRoot(_ context.Context, _ []byte) ([32]byte, error) {
+	if m.ErrorToReturn != nil {
+		return [32]byte{}, m.ErrorToReturn
+	}
+	return m.RootToReturn, nil
+}
+
 // BlobSidecars --
 func (*MockBlocker) BlobSidecars(_ context.Context, _ string, _ ...options.BlobsOption) ([]*blocks.VerifiedROBlob, *core.RpcError) {
 	return nil, &core.RpcError{}

beacon-chain/state/interfaces_gloas.go

@@ -3,7 +3,6 @@ package state
 import (
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 )
 
@@ -14,11 +13,6 @@ type writeOnlyGloasFields interface {
 	RotateBuilderPendingPayments() error
 	AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal) error
 	UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val byte) error
-
-	SetPayloadExpectedWithdrawals(withdrawals []*enginev1.Withdrawal) error
-	DequeueBuilderPendingWithdrawals(num uint64) error
-	SetNextWithdrawalBuilderIndex(idx primitives.BuilderIndex) error
-	DecreaseBuilderBalance(builderIndex primitives.BuilderIndex, amount uint64) error
 }
 
 type readOnlyGloasFields interface {
@@ -27,12 +21,4 @@ type readOnlyGloasFields interface {
 	CanBuilderCoverBid(primitives.BuilderIndex, primitives.Gwei) (bool, error)
 	LatestBlockHash() ([32]byte, error)
 	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
-
-	IsParentBlockFull() (bool, error)
-	BuildersCount() int
-	Builders() ([]*ethpb.Builder, error)
-	NextWithdrawalBuilderIndex() (primitives.BuilderIndex, error)
-	BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error)
-
-	ExpectedWithdrawalsGloas() ([]*enginev1.Withdrawal, uint64, uint64, primitives.BuilderIndex, error)
 }

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

@@ -15,7 +15,6 @@ go_library(
         "getters_eth1.go",
         "getters_exit.go",
         "getters_gloas.go",
-        "getters_gloas_withdrawals.go",
         "getters_misc.go",
         "getters_participation.go",
         "getters_payload_header.go",

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

@@ -1,7 +1,6 @@
 package state_native
 
 import (
-	"bytes"
 	"fmt"
 
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -11,22 +10,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
 )
 
-// IsParentBlockFull returns true when the latest bid was fulfilled with a payload.
-func (b *BeaconState) IsParentBlockFull() (bool, error) {
-	if b.version < version.Gloas {
-		return false, errNotSupported("IsParentBlockFull", b.version)	
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.latestExecutionPayloadBid == nil {
-		return false, nil
-	}
-
-	return bytes.Equal(b.latestExecutionPayloadBid.BlockHash, b.latestBlockHash), nil
-}
-
 // LatestBlockHash returns the hash of the latest execution block.
 func (b *BeaconState) LatestBlockHash() ([32]byte, error) {
 	if b.version < version.Gloas {
@@ -164,56 +147,3 @@ func (b *BeaconState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment,
 
 	return b.builderPendingPaymentsVal(), nil
 }
-
-// BuilderPendingWithdrawals returns the builder pending withdrawals queue.
-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
-}
-
-// BuildersCount returns the number of builders in the registry.
-func (b *BeaconState) BuildersCount() int {
-	if b.version < version.Gloas {
-		return 0
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return len(b.builders)
-}
-
-// Builders returns 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()
-
-	builders := make([]*ethpb.Builder, len(b.builders))
-	for i := range b.builders {
-		builders[i] = ethpb.CopyBuilder(b.builders[i])
-	}
-
-	return builders, nil
-}
-
-// NextWithdrawalBuilderIndex returns the next builder index for the withdrawals sweep.
-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_withdrawals.go

@@ -1,165 +0,0 @@
-package state_native
-
-import (
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-// ExpectedWithdrawalsGloas returns the withdrawals that a proposer will need to pack in the next block
-// applied to the current state. It is also used by validators to check that the execution payload carried
-// the right number of withdrawals.
-//
-// Spec v1.7.0-alpha.1:
-//
-//	def get_expected_withdrawals(state: BeaconState) -> ExpectedWithdrawals:
-//	    withdrawal_index = state.next_withdrawal_index
-//	    withdrawals: List[Withdrawal] = []
-//
-//	    # [New in Gloas:EIP7732]
-//	    # Get builder withdrawals
-//	    builder_withdrawals, withdrawal_index, processed_builder_withdrawals_count = (
-//	        get_builder_withdrawals(state, withdrawal_index, withdrawals)
-//	    )
-//	    withdrawals.extend(builder_withdrawals)
-//
-//	    # Get partial withdrawals
-//	    partial_withdrawals, withdrawal_index, processed_partial_withdrawals_count = (
-//	        get_pending_partial_withdrawals(state, withdrawal_index, withdrawals)
-//	    )
-//	    withdrawals.extend(partial_withdrawals)
-//
-//	    # [New in Gloas:EIP7732]
-//	    # Get builders sweep withdrawals
-//	    builders_sweep_withdrawals, withdrawal_index, processed_builders_sweep_count = (
-//	        get_builders_sweep_withdrawals(state, withdrawal_index, withdrawals)
-//	    )
-//	    withdrawals.extend(builders_sweep_withdrawals)
-//
-//	    # Get validators sweep withdrawals
-//	    validators_sweep_withdrawals, withdrawal_index, processed_validators_sweep_count = (
-//	        get_validators_sweep_withdrawals(state, withdrawal_index, withdrawals)
-//	    )
-//	    withdrawals.extend(validators_sweep_withdrawals)
-//
-//	    return ExpectedWithdrawals(
-//	        withdrawals,
-//	        # [New in Gloas:EIP7732]
-//	        processed_builder_withdrawals_count,
-//	        processed_partial_withdrawals_count,
-//	        # [New in Gloas:EIP7732]
-//	        processed_builders_sweep_count,
-//	        processed_validators_sweep_count,
-//	    )
-func (b *BeaconState) ExpectedWithdrawalsGloas() ([]*enginev1.Withdrawal, uint64, uint64, primitives.BuilderIndex, error) {
-	if b.version < version.Gloas {
-		return nil, 0, 0, 0, errNotSupported("ExpectedWithdrawalsGloas", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	cfg := params.BeaconConfig()
-	withdrawals := make([]*enginev1.Withdrawal, 0, cfg.MaxWithdrawalsPerPayload)
-	withdrawalIndex := b.nextWithdrawalIndex
-
-	withdrawalIndex, processedBuilderWithdrawalsCount, err := b.appendBuilderWithdrawalsGloas(withdrawalIndex, &withdrawals)
-	if err != nil {
-		return nil, 0, 0, 0, err
-	}
-
-	withdrawalIndex, processedPartialWithdrawalsCount, err := b.appendPendingPartialWithdrawals(withdrawalIndex, &withdrawals)
-	if err != nil {
-		return nil, 0, 0, 0, err
-	}
-
-	withdrawalIndex, processedBuildersSweepCount, err := b.appendBuildersSweepWithdrawalsGloas(withdrawalIndex, &withdrawals)
-	if err != nil {
-		return nil, 0, 0, 0, err
-	}
-
-	err = b.appendValidatorsSweepWithdrawals(withdrawalIndex, &withdrawals)
-	if err != nil {
-		return nil, 0, 0, 0, err
-	}
-
-	return withdrawals, processedBuilderWithdrawalsCount, processedPartialWithdrawalsCount, b.nextWithdrawalBuilderIndex + primitives.BuilderIndex(processedBuildersSweepCount), nil
-}
-
-func (b *BeaconState) appendBuilderWithdrawalsGloas(withdrawalIndex uint64, withdrawals *[]*enginev1.Withdrawal) (uint64, uint64, error) {
-	cfg := params.BeaconConfig()
-	withdrawalsLimit := cfg.MaxWithdrawalsPerPayload - 1
-	ws := *withdrawals
-	var processedCount uint64
-	for _, w := range b.builderPendingWithdrawals {
-		if uint64(len(ws)) >= withdrawalsLimit {
-			break
-		}
-		if w == nil {
-			continue
-		}
-		ws = append(ws, &enginev1.Withdrawal{
-			Index: withdrawalIndex,
-			ValidatorIndex: primitives.ValidatorIndex(
-				uint64(primitives.BuilderIndex(w.BuilderIndex)) | cfg.BuilderIndexFlag,
-			),
-			Address: bytesutil.SafeCopyBytes(w.FeeRecipient),
-			Amount:  uint64(w.Amount),
-		})
-		withdrawalIndex++
-		processedCount++
-	}
-	*withdrawals = ws
-	return withdrawalIndex, processedCount, nil
-}
-
-func (b *BeaconState) appendBuildersSweepWithdrawalsGloas(withdrawalIndex uint64, withdrawals *[]*enginev1.Withdrawal) (uint64, uint64, error) {
-	cfg := params.BeaconConfig()
-	withdrawalsLimit := cfg.MaxWithdrawalsPerPayload - 1
-	priorWithdrawalCount := uint64(len(*withdrawals))
-
-	if priorWithdrawalCount >= withdrawalsLimit || len(b.builders) == 0 {
-		return withdrawalIndex, 0, nil
-	}
-
-	ws := *withdrawals
-	epoch := slots.ToEpoch(b.slot)
-
-	buildersLimit := len(b.builders)
-	if maxBuilders := int(cfg.MaxBuildersPerWithdrawalsSweep); buildersLimit > maxBuilders {
-		buildersLimit = maxBuilders
-	}
-
-	builderIndex := b.nextWithdrawalBuilderIndex
-	if uint64(builderIndex) >= uint64(len(b.builders)) {
-		return withdrawalIndex, 0, fmt.Errorf("next withdrawal builder index %d out of range", builderIndex)
-	}
-	var processedCount uint64
-	for i := 0; i < buildersLimit; i++ {
-		if uint64(len(ws)) >= withdrawalsLimit {
-			break
-		}
-
-		builder := b.builders[builderIndex]
-		if builder != nil && builder.WithdrawableEpoch <= epoch && builder.Balance > 0 {
-			ws = append(ws, &enginev1.Withdrawal{
-				Index:          withdrawalIndex,
-				ValidatorIndex: primitives.ValidatorIndex(uint64(builderIndex) | cfg.BuilderIndexFlag),
-				Address:        bytesutil.SafeCopyBytes(builder.ExecutionAddress),
-				Amount:         uint64(builder.Balance),
-			})
-			withdrawalIndex++
-		}
-
-		builderIndex = primitives.BuilderIndex((uint64(builderIndex) + 1) % uint64(len(b.builders)))
-		processedCount++
-	}
-
-	*withdrawals = ws
-	return withdrawalIndex, processedCount, nil
-}

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

@@ -133,22 +133,11 @@ func (b *BeaconState) appendPendingPartialWithdrawals(withdrawalIndex uint64, wi
 		return withdrawalIndex, 0, nil
 	}
 
-	cfg := params.BeaconConfig()
-	withdrawalsLimit := min(
-		uint64(len(*withdrawals))+cfg.MaxPendingPartialsPerWithdrawalsSweep,
-		cfg.MaxWithdrawalsPerPayload-1,
-	)
-	if uint64(len(*withdrawals)) > withdrawalsLimit {
-		return withdrawalIndex, 0, fmt.Errorf("prior withdrawals length %d exceeds limit %d", len(*withdrawals), withdrawalsLimit)
-	}
-
 	ws := *withdrawals
 	epoch := slots.ToEpoch(b.slot)
 	var processedPartialWithdrawalsCount uint64
 	for _, w := range b.pendingPartialWithdrawals {
-		isWithdrawable := w.WithdrawableEpoch <= epoch
-		hasReachedLimit := uint64(len(ws)) >= withdrawalsLimit
-		if !isWithdrawable || hasReachedLimit {
+		if w.WithdrawableEpoch > epoch || len(ws) >= int(params.BeaconConfig().MaxPendingPartialsPerWithdrawalsSweep) {
 			break
 		}
 
@@ -160,7 +149,7 @@ func (b *BeaconState) appendPendingPartialWithdrawals(withdrawalIndex uint64, wi
 		if err != nil {
 			return withdrawalIndex, 0, fmt.Errorf("could not retrieve balance at index %d: %w", w.Index, err)
 		}
-		hasSufficientEffectiveBalance := v.EffectiveBalance() >= cfg.MinActivationBalance
+		hasSufficientEffectiveBalance := v.EffectiveBalance() >= params.BeaconConfig().MinActivationBalance
 		var totalWithdrawn uint64
 		for _, wi := range ws {
 			if wi.ValidatorIndex == w.Index {
@@ -171,9 +160,9 @@ func (b *BeaconState) appendPendingPartialWithdrawals(withdrawalIndex uint64, wi
 		if err != nil {
 			return withdrawalIndex, 0, errors.Wrapf(err, "failed to subtract balance %d with total withdrawn %d", vBal, totalWithdrawn)
 		}
-		hasExcessBalance := balance > cfg.MinActivationBalance
-		if v.ExitEpoch() == cfg.FarFutureEpoch && hasSufficientEffectiveBalance && hasExcessBalance {
-			amount := min(balance-cfg.MinActivationBalance, w.Amount)
+		hasExcessBalance := balance > params.BeaconConfig().MinActivationBalance
+		if v.ExitEpoch() == params.BeaconConfig().FarFutureEpoch && hasSufficientEffectiveBalance && hasExcessBalance {
+			amount := min(balance-params.BeaconConfig().MinActivationBalance, w.Amount)
 			ws = append(ws, &enginev1.Withdrawal{
 				Index:          withdrawalIndex,
 				ValidatorIndex: w.Index,

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

@@ -1,7 +1,6 @@
 package state_native
 
 import (
-	"errors"
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
@@ -9,32 +8,10 @@ import (
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"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/runtime/version"
 )
 
-// SetPayloadExpectedWithdrawals stores the expected withdrawals for the next payload.
-func (b *BeaconState) SetPayloadExpectedWithdrawals(withdrawals []*enginev1.Withdrawal) error {
-	if b.version < version.Gloas {
-		return errNotSupported("SetPayloadExpectedWithdrawals", b.version)
-	}
-
-	if withdrawals == nil {
-		return errors.New("cannot set nil payload expected withdrawals")
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.sharedFieldReferences[types.PayloadExpectedWithdrawals].MinusRef()
-	b.sharedFieldReferences[types.PayloadExpectedWithdrawals] = stateutil.NewRef(1)
-	b.payloadExpectedWithdrawals = withdrawals
-	b.markFieldAsDirty(types.PayloadExpectedWithdrawals)
-
-	return nil
-}
-
 // RotateBuilderPendingPayments rotates the queue by dropping slots per epoch payments from the
 // front and appending slots per epoch empty payments to the end.
 // This implements: state.builder_pending_payments = state.builder_pending_payments[SLOTS_PER_EPOCH:] + [BuilderPendingPayment() for _ in range(SLOTS_PER_EPOCH)]
@@ -92,38 +69,6 @@ func (b *BeaconState) AppendBuilderPendingWithdrawals(withdrawals []*ethpb.Build
 	return nil
 }
 
-// DequeueBuilderPendingWithdrawals removes processed builder withdrawals from the front of the queue.
-func (b *BeaconState) DequeueBuilderPendingWithdrawals(n uint64) error {
-	if b.version < version.Gloas {
-		return errNotSupported("DequeueBuilderPendingWithdrawals", b.version)
-	}
-
-	if n > uint64(len(b.builderPendingWithdrawals)) {
-		return errors.New("cannot dequeue more builder withdrawals than are in the queue")
-	}
-
-	if n == 0 {
-		return nil
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if b.sharedFieldReferences[types.BuilderPendingWithdrawals].Refs() > 1 {
-		withdrawals := make([]*ethpb.BuilderPendingWithdrawal, len(b.builderPendingWithdrawals))
-		copy(withdrawals, b.builderPendingWithdrawals)
-		b.builderPendingWithdrawals = withdrawals
-		b.sharedFieldReferences[types.BuilderPendingWithdrawals].MinusRef()
-		b.sharedFieldReferences[types.BuilderPendingWithdrawals] = stateutil.NewRef(1)
-	}
-
-	b.builderPendingWithdrawals = b.builderPendingWithdrawals[n:]
-	b.markFieldAsDirty(types.BuilderPendingWithdrawals)
-	b.rebuildTrie[types.BuilderPendingWithdrawals] = true
-
-	return nil
-}
-
 // SetExecutionPayloadBid sets the latest execution payload bid in the state.
 func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error {
 	if b.version < version.Gloas {
@@ -216,65 +161,3 @@ func (b *BeaconState) UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val
 	b.markFieldAsDirty(types.ExecutionPayloadAvailability)
 	return nil
 }
-
-// SetNextWithdrawalBuilderIndex sets the next builder index for the withdrawals sweep.
-func (b *BeaconState) SetNextWithdrawalBuilderIndex(index primitives.BuilderIndex) error {
-	if b.version < version.Gloas {
-		return errNotSupported("SetNextWithdrawalBuilderIndex", b.version)
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.nextWithdrawalBuilderIndex = index
-	b.markFieldAsDirty(types.NextWithdrawalBuilderIndex)
-	return nil
-}
-
-// DecreaseBuilderBalance decreases the builder's balance by amount (saturating at 0).
-func (b *BeaconState) DecreaseBuilderBalance(builderIndex primitives.BuilderIndex, amount uint64) error {
-	if b.version < version.Gloas {
-		return errNotSupported("DecreaseBuilderBalance", b.version)
-	}
-	if amount == 0 {
-		return nil
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	idx := uint64(builderIndex)
-	if idx >= uint64(len(b.builders)) {
-		return fmt.Errorf("builder index %d out of range (len=%d)", builderIndex, len(b.builders))
-	}
-
-	// Copy-on-write for shared builders registry.
-	if b.sharedFieldReferences[types.Builders].Refs() > 1 {
-		builders := make([]*ethpb.Builder, len(b.builders))
-		copy(builders, b.builders)
-		b.builders = builders
-		b.sharedFieldReferences[types.Builders].MinusRef()
-		b.sharedFieldReferences[types.Builders] = stateutil.NewRef(1)
-
-		// Ensure we don't mutate a shared builder pointer.
-		if b.builders[idx] != nil {
-			b.builders[idx] = ethpb.CopyBuilder(b.builders[idx])
-		}
-	}
-
-	builder := b.builders[idx]
-	if builder == nil {
-		return fmt.Errorf("builder at index %d is nil", builderIndex)
-	}
-
-	bal := uint64(builder.Balance)
-	if amount >= bal {
-		builder.Balance = 0
-	} else {
-		builder.Balance = primitives.Gwei(bal - amount)
-	}
-
-	b.markFieldAsDirty(types.Builders)
-	b.addDirtyIndices(types.Builders, []uint64{idx})
-	return nil
-}

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

@@ -318,62 +318,6 @@ func TestUpdateExecutionPayloadAvailabilityAtIndex_OutOfRange(t *testing.T) {
 	}
 }
 
-func TestDecreaseBuilderBalance(t *testing.T) {
-	t.Run("previous fork returns expected error", func(t *testing.T) {
-		st := &BeaconState{version: version.Fulu}
-		err := st.DecreaseBuilderBalance(0, 1)
-		require.ErrorContains(t, "DecreaseBuilderBalance", err)
-	})
-
-	t.Run("decreases and saturates", func(t *testing.T) {
-		st := &BeaconState{
-			version:     version.Gloas,
-			dirtyFields: make(map[types.FieldIndex]bool),
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.Builders: stateutil.NewRef(1),
-			},
-			builders: []*ethpb.Builder{
-				{Balance: 10},
-			},
-		}
-
-		require.NoError(t, st.DecreaseBuilderBalance(0, 3))
-		require.Equal(t, uint64(7), uint64(st.builders[0].Balance))
-		require.Equal(t, true, st.dirtyFields[types.Builders])
-
-		require.NoError(t, st.DecreaseBuilderBalance(0, 100))
-		require.Equal(t, uint64(0), uint64(st.builders[0].Balance))
-	})
-
-	t.Run("copy-on-write preserves shared state", func(t *testing.T) {
-		sharedRef := stateutil.NewRef(2)
-		sharedBuilders := []*ethpb.Builder{
-			{Balance: 10},
-		}
-
-		st1 := &BeaconState{
-			version:     version.Gloas,
-			dirtyFields: make(map[types.FieldIndex]bool),
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.Builders: sharedRef,
-			},
-			builders: sharedBuilders,
-		}
-		st2 := &BeaconState{
-			version:     version.Gloas,
-			dirtyFields: make(map[types.FieldIndex]bool),
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.Builders: sharedRef,
-			},
-			builders: sharedBuilders,
-		}
-
-		require.NoError(t, st1.DecreaseBuilderBalance(0, 3))
-		require.Equal(t, uint64(7), uint64(st1.builders[0].Balance))
-		require.Equal(t, uint64(10), uint64(st2.builders[0].Balance))
-	})
-}
-
 func newGloasStateWithAvailability(t *testing.T, availability []byte) *BeaconState {
 	t.Helper()
 

changelog/james-prysm_blocker-for-block-root.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- optimizing /eth/v1/beacon/blocks/{block_id}/root endpoint by reusing blocker lookup instead of duplicated logic.

config/params/config.go

@@ -47,7 +47,6 @@ type BeaconChainConfig struct {
 	HysteresisQuotient             uint64 `yaml:"HYSTERESIS_QUOTIENT" spec:"true"`                // HysteresisQuotient defines the hysteresis quotient for effective balance calculations.
 	HysteresisDownwardMultiplier   uint64 `yaml:"HYSTERESIS_DOWNWARD_MULTIPLIER" spec:"true"`     // HysteresisDownwardMultiplier defines the hysteresis downward multiplier for effective balance calculations.
 	HysteresisUpwardMultiplier     uint64 `yaml:"HYSTERESIS_UPWARD_MULTIPLIER" spec:"true"`       // HysteresisUpwardMultiplier defines the hysteresis upward multiplier for effective balance calculations.
-	BuilderIndexFlag               uint64 `yaml:"BUILDER_INDEX_FLAG" spec:"true"`                  // BuilderIndexFlag marks a ValidatorIndex as a BuilderIndex when the bit is set.
 
 	// Gwei value constants.
 	MinDepositAmount          uint64 `yaml:"MIN_DEPOSIT_AMOUNT" spec:"true"`          // MinDepositAmount is the minimum amount of Gwei a validator can send to the deposit contract at once (lower amounts will be reverted).
@@ -127,7 +126,6 @@ type BeaconChainConfig struct {
 	MaxWithdrawalsPerPayload         uint64 `yaml:"MAX_WITHDRAWALS_PER_PAYLOAD" spec:"true"`          // MaxWithdrawalsPerPayload defines the maximum number of withdrawals in a block.
 	MaxBlsToExecutionChanges         uint64 `yaml:"MAX_BLS_TO_EXECUTION_CHANGES" spec:"true"`         // MaxBlsToExecutionChanges defines the maximum number of BLS-to-execution-change objects in a block.
 	MaxValidatorsPerWithdrawalsSweep uint64 `yaml:"MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP" spec:"true"` // MaxValidatorsPerWithdrawalsSweep bounds the size of the sweep searching for withdrawals per slot.
-	MaxBuildersPerWithdrawalsSweep   uint64 `yaml:"MAX_BUILDERS_PER_WITHDRAWALS_SWEEP" spec:"true"`   // MaxBuildersPerWithdrawalsSweep bounds the size of the builder withdrawals sweep per slot.
 
 	// BLS domain values.
 	DomainBeaconProposer              [4]byte `yaml:"DOMAIN_BEACON_PROPOSER" spec:"true"`                // DomainBeaconProposer defines the BLS signature domain for beacon proposal verification.

config/params/loader.go

@@ -194,8 +194,6 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("SHARD_COMMITTEE_PERIOD: %d", cfg.ShardCommitteePeriod),
 		fmt.Sprintf("MIN_VALIDATOR_WITHDRAWABILITY_DELAY: %d", cfg.MinValidatorWithdrawabilityDelay),
 		fmt.Sprintf("MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP: %d", cfg.MaxValidatorsPerWithdrawalsSweep),
-		fmt.Sprintf("MAX_BUILDERS_PER_WITHDRAWALS_SWEEP: %d", cfg.MaxBuildersPerWithdrawalsSweep),
-		fmt.Sprintf("BUILDER_INDEX_FLAG: %d", cfg.BuilderIndexFlag),
 		fmt.Sprintf("MAX_SEED_LOOKAHEAD: %d", cfg.MaxSeedLookahead),
 		fmt.Sprintf("EJECTION_BALANCE: %d", cfg.EjectionBalance),
 		fmt.Sprintf("MIN_PER_EPOCH_CHURN_LIMIT: %d", cfg.MinPerEpochChurnLimit),

config/params/mainnet_config.go

@@ -83,7 +83,6 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	HysteresisQuotient:             4,
 	HysteresisDownwardMultiplier:   1,
 	HysteresisUpwardMultiplier:     5,
-	BuilderIndexFlag:               1099511627776,
 
 	// Gwei value constants.
 	MinDepositAmount:          1 * 1e9,
@@ -170,7 +169,6 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	MaxWithdrawalsPerPayload:         16,
 	MaxBlsToExecutionChanges:         16,
 	MaxValidatorsPerWithdrawalsSweep: 16384,
-	MaxBuildersPerWithdrawalsSweep:   16384,
 
 	// BLS domain values.
 	DomainBeaconProposer:              bytesutil.Uint32ToBytes4(0x00000000),

config/params/testnet_config_test.go

@@ -49,7 +49,6 @@ func compareConfigs(t *testing.T, expected, actual *params.BeaconChainConfig) {
 	require.DeepEqual(t, expected.HysteresisQuotient, actual.HysteresisQuotient)
 	require.DeepEqual(t, expected.HysteresisDownwardMultiplier, actual.HysteresisDownwardMultiplier)
 	require.DeepEqual(t, expected.HysteresisUpwardMultiplier, actual.HysteresisUpwardMultiplier)
-	require.DeepEqual(t, expected.BuilderIndexFlag, actual.BuilderIndexFlag)
 	require.DeepEqual(t, expected.MinDepositAmount, actual.MinDepositAmount)
 	require.DeepEqual(t, expected.MaxEffectiveBalance, actual.MaxEffectiveBalance)
 	require.DeepEqual(t, expected.EjectionBalance, actual.EjectionBalance)
@@ -95,7 +94,6 @@ func compareConfigs(t *testing.T, expected, actual *params.BeaconChainConfig) {
 	require.DeepEqual(t, expected.MaxDeposits, actual.MaxDeposits)
 	require.DeepEqual(t, expected.MaxVoluntaryExits, actual.MaxVoluntaryExits)
 	require.DeepEqual(t, expected.MaxWithdrawalsPerPayload, actual.MaxWithdrawalsPerPayload)
-	require.DeepEqual(t, expected.MaxBuildersPerWithdrawalsSweep, actual.MaxBuildersPerWithdrawalsSweep)
 	require.DeepEqual(t, expected.DomainBeaconProposer, actual.DomainBeaconProposer)
 	require.DeepEqual(t, expected.DomainRandao, actual.DomainRandao)
 	require.DeepEqual(t, expected.DomainBeaconAttester, actual.DomainBeaconAttester)

hack/check-logs.sh

@@ -8,12 +8,13 @@ cd "$ROOT_DIR"
 ./hack/gen-logs.sh
 
 # Fail if that changed anything
-if ! git diff --quiet -- ./; then
+if ! git diff --quiet -- ./ || [[ -n "$(git ls-files --others --exclude-standard -- ./)" ]]; then
   echo "ERROR: log.go files are out of date. Please run:"
   echo "  ./hack/gen-logs.sh"
   echo "and commit the changes."
   echo
   git diff --stat -- ./ || true
+  git status --porcelain -- ./ || true
   exit 1
 fi