add back external assembler

Add Hash() and HashChunks() wrapper functions in crypto/hash/htr that
handle the EnableHashtree flag check internally. This eliminates
duplicated branching logic across 6 call sites in 3 files.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

beacon-chain/core/gloas/BUILD.bazel

@@ -1,45 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["bid.go"],
-    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//crypto/bls/common:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//time/slots:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["bid_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//crypto/bls/common:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/validator-client:go_default_library",
-        "//runtime/version:go_default_library",
-        "//testing/require:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_prysmaticlabs_fastssz//:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-    ],
-)

beacon-chain/core/gloas/bid.go

@@ -1,197 +0,0 @@
-package gloas
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-// ProcessExecutionPayloadBid processes a signed execution payload bid in the Gloas fork.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// process_execution_payload_bid(state: BeaconState, block: BeaconBlock):
-//
-//	signed_bid = block.body.signed_execution_payload_bid
-//	bid = signed_bid.message
-//	builder_index = bid.builder_index
-//	amount = bid.value
-//	if builder_index == BUILDER_INDEX_SELF_BUILD:
-//	  assert amount == 0
-//	  assert signed_bid.signature == G2_POINT_AT_INFINITY
-//	else:
-//	  assert is_active_builder(state, builder_index)
-//	  assert can_builder_cover_bid(state, builder_index, amount)
-//	  assert verify_execution_payload_bid_signature(state, signed_bid)
-//	assert bid.slot == block.slot
-//	assert bid.parent_block_hash == state.latest_block_hash
-//	assert bid.parent_block_root == block.parent_root
-//	assert bid.prev_randao == get_randao_mix(state, get_current_epoch(state))
-//	if amount > 0:
-//	  state.builder_pending_payments[...] = BuilderPendingPayment(weight=0, withdrawal=BuilderPendingWithdrawal(fee_recipient=bid.fee_recipient, amount=amount, builder_index=builder_index))
-//	state.latest_execution_payload_bid = bid
-func ProcessExecutionPayloadBid(st state.BeaconState, block interfaces.ReadOnlyBeaconBlock) error {
-	signedBid, err := block.Body().SignedExecutionPayloadBid()
-	if err != nil {
-		return fmt.Errorf("failed to get signed execution payload bid: %w", err)
-	}
-
-	wrappedBid, err := blocks.WrappedROSignedExecutionPayloadBid(signedBid)
-	if err != nil {
-		return fmt.Errorf("failed to wrap signed bid: %w", err)
-	}
-
-	bid, err := wrappedBid.Bid()
-	if err != nil {
-		return fmt.Errorf("failed to get bid from wrapped bid: %w", err)
-	}
-
-	builderIndex := bid.BuilderIndex()
-	amount := bid.Value()
-
-	if builderIndex == params.BeaconConfig().BuilderIndexSelfBuild {
-		if amount != 0 {
-			return fmt.Errorf("self-build amount must be zero, got %d", amount)
-		}
-		if wrappedBid.Signature() != common.InfiniteSignature {
-			return errors.New("self-build signature must be point at infinity")
-		}
-	} else {
-		ok, err := st.IsActiveBuilder(builderIndex)
-		if err != nil {
-			return fmt.Errorf("builder active check failed: %w", err)
-		}
-		if !ok {
-			return fmt.Errorf("builder %d is not active", builderIndex)
-		}
-
-		ok, err = st.CanBuilderCoverBid(builderIndex, amount)
-		if err != nil {
-			return fmt.Errorf("builder balance check failed: %w", err)
-		}
-		if !ok {
-			return fmt.Errorf("builder %d cannot cover bid amount %d", builderIndex, amount)
-		}
-
-		if err := validatePayloadBidSignature(st, wrappedBid); err != nil {
-			return fmt.Errorf("bid signature validation failed: %w", err)
-		}
-	}
-
-	if err := validateBidConsistency(st, bid, block); err != nil {
-		return fmt.Errorf("bid consistency validation failed: %w", err)
-	}
-
-	if amount > 0 {
-		feeRecipient := bid.FeeRecipient()
-		pendingPayment := &ethpb.BuilderPendingPayment{
-			Weight: 0,
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: feeRecipient[:],
-				Amount:       amount,
-				BuilderIndex: builderIndex,
-			},
-		}
-		slotIndex := params.BeaconConfig().SlotsPerEpoch + (bid.Slot() % params.BeaconConfig().SlotsPerEpoch)
-		if err := st.SetBuilderPendingPayment(slotIndex, pendingPayment); err != nil {
-			return fmt.Errorf("failed to set pending payment: %w", err)
-		}
-	}
-
-	if err := st.SetExecutionPayloadBid(bid); err != nil {
-		return fmt.Errorf("failed to cache execution payload bid: %w", err)
-	}
-
-	return nil
-}
-
-// validateBidConsistency checks that the bid is consistent with the current beacon state.
-func validateBidConsistency(st state.BeaconState, bid interfaces.ROExecutionPayloadBid, block interfaces.ReadOnlyBeaconBlock) error {
-	if bid.Slot() != block.Slot() {
-		return fmt.Errorf("bid slot %d does not match block slot %d", bid.Slot(), block.Slot())
-	}
-
-	latestBlockHash, err := st.LatestBlockHash()
-	if err != nil {
-		return fmt.Errorf("failed to get latest block hash: %w", err)
-	}
-	if bid.ParentBlockHash() != latestBlockHash {
-		return fmt.Errorf("bid parent block hash mismatch: got %x, expected %x",
-			bid.ParentBlockHash(), latestBlockHash)
-	}
-
-	if bid.ParentBlockRoot() != block.ParentRoot() {
-		return fmt.Errorf("bid parent block root mismatch: got %x, expected %x",
-			bid.ParentBlockRoot(), block.ParentRoot())
-	}
-
-	randaoMix, err := helpers.RandaoMix(st, slots.ToEpoch(st.Slot()))
-	if err != nil {
-		return fmt.Errorf("failed to get randao mix: %w", err)
-	}
-	if bid.PrevRandao() != [32]byte(randaoMix) {
-		return fmt.Errorf("bid prev randao mismatch: got %x, expected %x", bid.PrevRandao(), randaoMix)
-	}
-
-	return nil
-}
-
-// validatePayloadBidSignature verifies the BLS signature on a signed execution payload bid.
-// It validates that the signature was created by the builder specified in the bid
-// using the appropriate domain for the beacon builder.
-func validatePayloadBidSignature(st state.ReadOnlyBeaconState, signedBid interfaces.ROSignedExecutionPayloadBid) error {
-	bid, err := signedBid.Bid()
-	if err != nil {
-		return fmt.Errorf("failed to get bid: %w", err)
-	}
-
-	builder, err := st.BuilderAtIndex(bid.BuilderIndex())
-	if err != nil {
-		return fmt.Errorf("failed to get builder: %w", err)
-	}
-	if len(builder.Pubkey) != fieldparams.BLSPubkeyLength {
-		return fmt.Errorf("invalid builder public key length: %d", len(builder.Pubkey))
-	}
-
-	publicKey, err := bls.PublicKeyFromBytes(builder.Pubkey)
-	if err != nil {
-		return fmt.Errorf("invalid builder public key: %w", err)
-	}
-
-	signatureBytes := signedBid.Signature()
-	signature, err := bls.SignatureFromBytes(signatureBytes[:])
-	if err != nil {
-		return fmt.Errorf("invalid signature format: %w", err)
-	}
-
-	currentEpoch := slots.ToEpoch(bid.Slot())
-	domain, err := signing.Domain(
-		st.Fork(),
-		currentEpoch,
-		params.BeaconConfig().DomainBeaconBuilder,
-		st.GenesisValidatorsRoot(),
-	)
-	if err != nil {
-		return fmt.Errorf("failed to compute signing domain: %w", err)
-	}
-
-	signingRoot, err := signedBid.SigningRoot(domain)
-	if err != nil {
-		return fmt.Errorf("failed to compute signing root: %w", err)
-	}
-
-	if !signature.Verify(publicKey, signingRoot[:]) {
-		return fmt.Errorf("signature verification failed: %w", signing.ErrSigFailedToVerify)
-	}
-
-	return nil
-}

beacon-chain/core/gloas/bid_test.go

@@ -1,628 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	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/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	validatorpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1/validator-client"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	fastssz "github.com/prysmaticlabs/fastssz"
-	"google.golang.org/protobuf/proto"
-)
-
-type stubBlockBody struct {
-	signedBid *ethpb.SignedExecutionPayloadBid
-}
-
-func (s stubBlockBody) Version() int                                 { return version.Gloas }
-func (s stubBlockBody) RandaoReveal() [96]byte                       { return [96]byte{} }
-func (s stubBlockBody) Eth1Data() *ethpb.Eth1Data                    { return nil }
-func (s stubBlockBody) Graffiti() [32]byte                           { return [32]byte{} }
-func (s stubBlockBody) ProposerSlashings() []*ethpb.ProposerSlashing { return nil }
-func (s stubBlockBody) AttesterSlashings() []ethpb.AttSlashing       { return nil }
-func (s stubBlockBody) Attestations() []ethpb.Att                    { return nil }
-func (s stubBlockBody) Deposits() []*ethpb.Deposit                   { return nil }
-func (s stubBlockBody) VoluntaryExits() []*ethpb.SignedVoluntaryExit { return nil }
-func (s stubBlockBody) SyncAggregate() (*ethpb.SyncAggregate, error) { return nil, nil }
-func (s stubBlockBody) IsNil() bool                                  { return s.signedBid == nil }
-func (s stubBlockBody) HashTreeRoot() ([32]byte, error)              { return [32]byte{}, nil }
-func (s stubBlockBody) Proto() (proto.Message, error)                { return nil, nil }
-func (s stubBlockBody) Execution() (interfaces.ExecutionData, error) { return nil, nil }
-func (s stubBlockBody) BLSToExecutionChanges() ([]*ethpb.SignedBLSToExecutionChange, error) {
-	return nil, nil
-}
-func (s stubBlockBody) BlobKzgCommitments() ([][]byte, error) { return nil, nil }
-func (s stubBlockBody) ExecutionRequests() (*enginev1.ExecutionRequests, error) {
-	return nil, nil
-}
-func (s stubBlockBody) PayloadAttestations() ([]*ethpb.PayloadAttestation, error) {
-	return nil, nil
-}
-func (s stubBlockBody) SignedExecutionPayloadBid() (*ethpb.SignedExecutionPayloadBid, error) {
-	return s.signedBid, nil
-}
-func (s stubBlockBody) MarshalSSZ() ([]byte, error)         { return nil, nil }
-func (s stubBlockBody) MarshalSSZTo([]byte) ([]byte, error) { return nil, nil }
-func (s stubBlockBody) UnmarshalSSZ([]byte) error           { return nil }
-func (s stubBlockBody) SizeSSZ() int                        { return 0 }
-
-type stubBlock struct {
-	slot       primitives.Slot
-	proposer   primitives.ValidatorIndex
-	parentRoot [32]byte
-	body       stubBlockBody
-	v          int
-}
-
-func (s stubBlock) Slot() primitives.Slot                    { return s.slot }
-func (s stubBlock) ProposerIndex() primitives.ValidatorIndex { return s.proposer }
-func (s stubBlock) ParentRoot() [32]byte                     { return s.parentRoot }
-func (s stubBlock) StateRoot() [32]byte                      { return [32]byte{} }
-func (s stubBlock) Body() interfaces.ReadOnlyBeaconBlockBody { return s.body }
-func (s stubBlock) IsNil() bool                              { return false }
-func (s stubBlock) IsBlinded() bool                          { return false }
-func (s stubBlock) HashTreeRoot() ([32]byte, error)          { return [32]byte{}, nil }
-func (s stubBlock) Proto() (proto.Message, error)            { return nil, nil }
-func (s stubBlock) MarshalSSZ() ([]byte, error)              { return nil, nil }
-func (s stubBlock) MarshalSSZTo([]byte) ([]byte, error)      { return nil, nil }
-func (s stubBlock) UnmarshalSSZ([]byte) error                { return nil }
-func (s stubBlock) SizeSSZ() int                             { return 0 }
-func (s stubBlock) Version() int                             { return s.v }
-func (s stubBlock) AsSignRequestObject() (validatorpb.SignRequestObject, error) {
-	return nil, nil
-}
-func (s stubBlock) HashTreeRootWith(*fastssz.Hasher) error { return nil }
-
-func buildGloasState(t *testing.T, slot primitives.Slot, proposerIdx primitives.ValidatorIndex, builderIdx primitives.BuilderIndex, balance uint64, randao [32]byte, latestHash [32]byte, builderPubkey [48]byte) *state_native.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range blockRoots {
-		blockRoots[i] = bytes.Repeat([]byte{0xAA}, 32)
-		stateRoots[i] = bytes.Repeat([]byte{0xBB}, 32)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = randao[:]
-	}
-
-	withdrawalCreds := make([]byte, 32)
-	withdrawalCreds[0] = cfg.BuilderWithdrawalPrefixByte
-
-	validatorCount := int(proposerIdx) + 1
-	validators := make([]*ethpb.Validator, validatorCount)
-	balances := make([]uint64, validatorCount)
-	for i := range validatorCount {
-		validators[i] = &ethpb.Validator{
-			PublicKey:                  builderPubkey[:],
-			WithdrawalCredentials:      withdrawalCreds,
-			EffectiveBalance:           balance,
-			Slashed:                    false,
-			ActivationEligibilityEpoch: 0,
-			ActivationEpoch:            0,
-			ExitEpoch:                  cfg.FarFutureEpoch,
-			WithdrawableEpoch:          cfg.FarFutureEpoch,
-		}
-		balances[i] = balance
-	}
-
-	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
-	for i := range payments {
-		payments[i] = &ethpb.BuilderPendingPayment{Withdrawal: &ethpb.BuilderPendingWithdrawal{}}
-	}
-
-	var builders []*ethpb.Builder
-	if builderIdx != params.BeaconConfig().BuilderIndexSelfBuild {
-		builderCount := int(builderIdx) + 1
-		builders = make([]*ethpb.Builder, builderCount)
-		builders[builderCount-1] = &ethpb.Builder{
-			Pubkey:            builderPubkey[:],
-			Version:           []byte{0},
-			ExecutionAddress:  bytes.Repeat([]byte{0x01}, 20),
-			Balance:           primitives.Gwei(balance),
-			DepositEpoch:      0,
-			WithdrawableEpoch: cfg.FarFutureEpoch,
-		}
-	}
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                  slot,
-		GenesisValidatorsRoot: bytes.Repeat([]byte{0x11}, 32),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x22}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x22}, 4),
-			Epoch:           0,
-		},
-		BlockRoots:                blockRoots,
-		StateRoots:                stateRoots,
-		RandaoMixes:               randaoMixes,
-		Validators:                validators,
-		Balances:                  balances,
-		LatestBlockHash:           latestHash[:],
-		BuilderPendingPayments:    payments,
-		BuilderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{},
-		Builders:                  builders,
-		FinalizedCheckpoint: &ethpb.Checkpoint{
-			Epoch: 1,
-		},
-	}
-
-	st, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return st.(*state_native.BeaconState)
-}
-
-func signBid(t *testing.T, sk common.SecretKey, bid *ethpb.ExecutionPayloadBid, fork *ethpb.Fork, genesisRoot [32]byte) [96]byte {
-	t.Helper()
-	epoch := slots.ToEpoch(primitives.Slot(bid.Slot))
-	domain, err := signing.Domain(fork, epoch, params.BeaconConfig().DomainBeaconBuilder, genesisRoot[:])
-	require.NoError(t, err)
-	root, err := signing.ComputeSigningRoot(bid, domain)
-	require.NoError(t, err)
-	sig := sk.Sign(root[:]).Marshal()
-	var out [96]byte
-	copy(out[:], sig)
-	return out
-}
-
-func TestProcessExecutionPayloadBid_SelfBuildSuccess(t *testing.T) {
-	slot := primitives.Slot(12)
-	proposerIdx := primitives.ValidatorIndex(0)
-	builderIdx := params.BeaconConfig().BuilderIndexSelfBuild
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-	pubKey := [48]byte{}
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinActivationBalance+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  0,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: common.InfiniteSignature[:],
-	}
-
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	require.NoError(t, ProcessExecutionPayloadBid(state, block))
-
-	stateProto, ok := state.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, true, ok)
-	slotIndex := params.BeaconConfig().SlotsPerEpoch + (slot % params.BeaconConfig().SlotsPerEpoch)
-	require.Equal(t, primitives.Gwei(0), stateProto.BuilderPendingPayments[slotIndex].Withdrawal.Amount)
-}
-
-func TestProcessExecutionPayloadBid_SelfBuildNonZeroAmountFails(t *testing.T) {
-	slot := primitives.Slot(2)
-	proposerIdx := primitives.ValidatorIndex(0)
-	builderIdx := params.BeaconConfig().BuilderIndexSelfBuild
-	randao := [32]byte{}
-	latestHash := [32]byte{1}
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinActivationBalance+1000, randao, latestHash, [48]byte{})
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xAA}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xBB}, 32),
-		PrevRandao:             randao[:],
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  10,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xDD}, 20),
-	}
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: common.InfiniteSignature[:],
-	}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err := ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "self-build amount must be zero", err)
-}
-
-func TestProcessExecutionPayloadBid_PendingPaymentAndCacheBid(t *testing.T) {
-	slot := primitives.Slot(8)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	pub := sk.PublicKey().Marshal()
-	var pubKey [48]byte
-	copy(pubKey[:], pub)
-
-	balance := params.BeaconConfig().MinActivationBalance + 1_000_000
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, balance, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  500_000,
-		ExecutionPayment:       1,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: sig[:],
-	}
-
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx, // not self-build
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	require.NoError(t, ProcessExecutionPayloadBid(state, block))
-
-	stateProto, ok := state.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, true, ok)
-	slotIndex := params.BeaconConfig().SlotsPerEpoch + (slot % params.BeaconConfig().SlotsPerEpoch)
-	require.Equal(t, primitives.Gwei(500_000), stateProto.BuilderPendingPayments[slotIndex].Withdrawal.Amount)
-
-	require.NotNil(t, stateProto.LatestExecutionPayloadBid)
-	require.Equal(t, primitives.BuilderIndex(1), stateProto.LatestExecutionPayloadBid.BuilderIndex)
-	require.Equal(t, primitives.Gwei(500_000), stateProto.LatestExecutionPayloadBid.Value)
-}
-
-func TestProcessExecutionPayloadBid_BuilderNotActive(t *testing.T) {
-	slot := primitives.Slot(4)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0x01}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0x02}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-	// Make builder inactive by setting withdrawable_epoch.
-	stateProto := state.ToProto().(*ethpb.BeaconStateGloas)
-	stateProto.Builders[int(builderIdx)].WithdrawableEpoch = 0
-	stateIface, err := state_native.InitializeFromProtoGloas(stateProto)
-	require.NoError(t, err)
-	state = stateIface.(*state_native.BeaconState)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0x03}, 32),
-		BlockHash:              bytes.Repeat([]byte{0x04}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  10,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x05}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x06}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "is not active", err)
-}
-
-func TestProcessExecutionPayloadBid_CannotCoverBid(t *testing.T) {
-	slot := primitives.Slot(5)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0x0A}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0x0B}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+10, randao, latestHash, pubKey)
-	stateProto := state.ToProto().(*ethpb.BeaconStateGloas)
-	// Add pending balances to push below required balance.
-	stateProto.BuilderPendingWithdrawals = []*ethpb.BuilderPendingWithdrawal{
-		{Amount: 15, BuilderIndex: builderIdx},
-	}
-	stateProto.BuilderPendingPayments = []*ethpb.BuilderPendingPayment{
-		{Withdrawal: &ethpb.BuilderPendingWithdrawal{Amount: 20, BuilderIndex: builderIdx}},
-	}
-	stateIface, err := state_native.InitializeFromProtoGloas(stateProto)
-	require.NoError(t, err)
-	state = stateIface.(*state_native.BeaconState)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  25,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "cannot cover bid amount", err)
-}
-
-func TestProcessExecutionPayloadBid_InvalidSignature(t *testing.T) {
-	slot := primitives.Slot(6)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  10,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-	// Use an invalid signature.
-	invalidSig := [96]byte{1}
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: invalidSig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "bid signature validation failed", err)
-}
-
-func TestProcessExecutionPayloadBid_SlotMismatch(t *testing.T) {
-	slot := primitives.Slot(10)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xAA}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xBB}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot + 1, // mismatch
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xDD}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "bid slot", err)
-}
-
-func TestProcessExecutionPayloadBid_ParentHashMismatch(t *testing.T) {
-	slot := primitives.Slot(11)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        bytes.Repeat([]byte{0x11}, 32), // mismatch
-		ParentBlockRoot:        bytes.Repeat([]byte{0x22}, 32),
-		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "parent block hash mismatch", err)
-}
-
-func TestProcessExecutionPayloadBid_ParentRootMismatch(t *testing.T) {
-	slot := primitives.Slot(12)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	parentRoot := bytes.Repeat([]byte{0x22}, 32)
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        parentRoot,
-		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bytes.Repeat([]byte{0x99}, 32)), // mismatch
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "parent block root mismatch", err)
-}
-
-func TestProcessExecutionPayloadBid_PrevRandaoMismatch(t *testing.T) {
-	slot := primitives.Slot(13)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0x22}, 32),
-		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:             bytes.Repeat([]byte{0x01}, 32), // mismatch
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "prev randao mismatch", err)
-}

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

@@ -168,8 +168,6 @@ func TestGetSpec(t *testing.T) {
 	config.BlobsidecarSubnetCount = 101
 	config.BlobsidecarSubnetCountElectra = 102
 	config.SyncMessageDueBPS = 103
-	config.BuilderWithdrawalPrefixByte = byte('b')
-	config.BuilderIndexSelfBuild = primitives.BuilderIndex(125)
 
 	var dbp [4]byte
 	copy(dbp[:], []byte{'0', '0', '0', '1'})
@@ -192,9 +190,6 @@ func TestGetSpec(t *testing.T) {
 	var daap [4]byte
 	copy(daap[:], []byte{'0', '0', '0', '7'})
 	config.DomainAggregateAndProof = daap
-	var dbb [4]byte
-	copy(dbb[:], []byte{'0', '0', '0', '8'})
-	config.DomainBeaconBuilder = dbb
 	var dam [4]byte
 	copy(dam[:], []byte{'1', '0', '0', '0'})
 	config.DomainApplicationMask = dam
@@ -210,7 +205,7 @@ func TestGetSpec(t *testing.T) {
 	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), &resp))
 	data, ok := resp.Data.(map[string]any)
 	require.Equal(t, true, ok)
-	assert.Equal(t, 178, len(data))
+	assert.Equal(t, 175, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -424,14 +419,8 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "0x0a000000", v)
 			case "DOMAIN_APPLICATION_BUILDER":
 				assert.Equal(t, "0x00000001", v)
-			case "DOMAIN_BEACON_BUILDER":
-				assert.Equal(t, "0x30303038", v)
 			case "DOMAIN_BLOB_SIDECAR":
 				assert.Equal(t, "0x00000000", v)
-			case "BUILDER_WITHDRAWAL_PREFIX":
-				assert.Equal(t, "0x62", v)
-			case "BUILDER_INDEX_SELF_BUILD":
-				assert.Equal(t, "125", v)
 			case "TRANSITION_TOTAL_DIFFICULTY":
 				assert.Equal(t, "0", v)
 			case "TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH":

beacon-chain/state/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "error.go",
         "interfaces.go",
-        "interfaces_gloas.go",
         "prometheus.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/state",

beacon-chain/state/interfaces.go

@@ -63,7 +63,6 @@ type ReadOnlyBeaconState interface {
 	ReadOnlyDeposits
 	ReadOnlyConsolidations
 	ReadOnlyProposerLookahead
-	readOnlyGloasFields
 	ToProtoUnsafe() any
 	ToProto() any
 	GenesisTime() time.Time
@@ -99,7 +98,6 @@ type WriteOnlyBeaconState interface {
 	WriteOnlyWithdrawals
 	WriteOnlyDeposits
 	WriteOnlyProposerLookahead
-	writeOnlyGloasFields
 	SetGenesisTime(val time.Time) error
 	SetGenesisValidatorsRoot(val []byte) error
 	SetSlot(val primitives.Slot) error

beacon-chain/state/interfaces_gloas.go

@@ -1,19 +0,0 @@
-package state
-
-import (
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-type writeOnlyGloasFields interface {
-	SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error
-	SetBuilderPendingPayment(index primitives.Slot, payment *ethpb.BuilderPendingPayment) error
-}
-
-type readOnlyGloasFields interface {
-	BuilderAtIndex(primitives.BuilderIndex) (*ethpb.Builder, error)
-	IsActiveBuilder(primitives.BuilderIndex) (bool, error)
-	CanBuilderCoverBid(primitives.BuilderIndex, primitives.Gwei) (bool, error)
-	LatestBlockHash() ([32]byte, error)
-}

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

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

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

@@ -1,128 +0,0 @@
-package state_native
-
-import (
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-)
-
-// LatestBlockHash returns the hash of the latest execution block.
-func (b *BeaconState) LatestBlockHash() ([32]byte, error) {
-	if b.version < version.Gloas {
-		return [32]byte{}, errNotSupported("LatestBlockHash", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.latestBlockHash == nil {
-		return [32]byte{}, nil
-	}
-
-	return [32]byte(b.latestBlockHash), nil
-}
-
-// BuilderAtIndex returns a copy of the builder at the provided index.
-func (b *BeaconState) BuilderAtIndex(builderIndex primitives.BuilderIndex) (*ethpb.Builder, error) {
-	if b.version < version.Gloas {
-		return nil, errNotSupported("BuilderAtIndex", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return b.builderAtIndex(builderIndex)
-}
-
-// IsActiveBuilder returns true if the builder placement is finalized and it has not initiated exit.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// def is_active_builder(state: BeaconState, builder_index: BuilderIndex) -> bool:
-//
-//	builder = state.builders[builder_index]
-//	return (
-//	    builder.deposit_epoch < state.finalized_checkpoint.epoch
-//	    and builder.withdrawable_epoch == FAR_FUTURE_EPOCH
-//	)
-func (b *BeaconState) IsActiveBuilder(builderIndex primitives.BuilderIndex) (bool, error) {
-	if b.version < version.Gloas {
-		return false, errNotSupported("IsActiveBuilder", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	builder, err := b.builderAtIndex(builderIndex)
-	if err != nil {
-		return false, err
-	}
-
-	finalizedEpoch := b.finalizedCheckpoint.Epoch
-	return builder.DepositEpoch < finalizedEpoch && builder.WithdrawableEpoch == params.BeaconConfig().FarFutureEpoch, nil
-}
-
-// CanBuilderCoverBid returns true if the builder has enough balance to cover the given bid amount.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// def can_builder_cover_bid(state: BeaconState, builder_index: BuilderIndex, bid_amount: Gwei) -> bool:
-//
-//	builder_balance = state.builders[builder_index].balance
-//	pending_withdrawals_amount = get_pending_balance_to_withdraw_for_builder(state, builder_index)
-//	min_balance = MIN_DEPOSIT_AMOUNT + pending_withdrawals_amount
-//	if builder_balance < min_balance:
-//	    return False
-//	return builder_balance - min_balance >= bid_amount
-func (b *BeaconState) CanBuilderCoverBid(builderIndex primitives.BuilderIndex, bidAmount primitives.Gwei) (bool, error) {
-	if b.version < version.Gloas {
-		return false, errNotSupported("CanBuilderCoverBid", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	builder, err := b.builderAtIndex(builderIndex)
-	if err != nil {
-		return false, err
-	}
-
-	pendingBalanceToWithdraw := b.builderPendingBalanceToWithdraw(builderIndex)
-	minBalance := params.BeaconConfig().MinDepositAmount + pendingBalanceToWithdraw
-
-	balance := uint64(builder.Balance)
-	if balance < minBalance {
-		return false, nil
-	}
-
-	return balance-minBalance >= uint64(bidAmount), nil
-}
-
-func (b *BeaconState) builderAtIndex(builderIndex primitives.BuilderIndex) (*ethpb.Builder, error) {
-	idx := uint64(builderIndex)
-	if idx >= uint64(len(b.builders)) {
-		return nil, fmt.Errorf("builder index %d out of range (len=%d)", builderIndex, len(b.builders))
-	}
-
-	builder := b.builders[idx]
-	if builder == nil {
-		return nil, fmt.Errorf("builder at index %d is nil", builderIndex)
-	}
-	return ethpb.CopyBuilder(builder), nil
-}
-
-// builderPendingBalanceToWithdraw mirrors get_pending_balance_to_withdraw_for_builder in the spec,
-// summing both pending withdrawals and pending payments for a builder.
-func (b *BeaconState) builderPendingBalanceToWithdraw(builderIndex primitives.BuilderIndex) uint64 {
-	var total uint64
-	for _, withdrawal := range b.builderPendingWithdrawals {
-		if withdrawal.BuilderIndex == builderIndex {
-			total += uint64(withdrawal.Amount)
-		}
-	}
-	for _, payment := range b.builderPendingPayments {
-		if payment.Withdrawal.BuilderIndex == builderIndex {
-			total += uint64(payment.Withdrawal.Amount)
-		}
-	}
-	return total
-}

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

@@ -1,149 +0,0 @@
-package state_native_test
-
-import (
-	"bytes"
-	"testing"
-
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
-)
-
-func TestLatestBlockHash(t *testing.T) {
-	t.Run("returns error before gloas", func(t *testing.T) {
-		st, _ := util.DeterministicGenesisState(t, 1)
-		_, err := st.LatestBlockHash()
-		require.ErrorContains(t, "is not supported", err)
-	})
-
-	t.Run("returns zero hash when unset", func(t *testing.T) {
-		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{})
-		require.NoError(t, err)
-
-		got, err := st.LatestBlockHash()
-		require.NoError(t, err)
-		require.Equal(t, [32]byte{}, got)
-	})
-
-	t.Run("returns configured hash", func(t *testing.T) {
-		hashBytes := bytes.Repeat([]byte{0xAB}, 32)
-		var want [32]byte
-		copy(want[:], hashBytes)
-
-		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			LatestBlockHash: hashBytes,
-		})
-		require.NoError(t, err)
-
-		got, err := st.LatestBlockHash()
-		require.NoError(t, err)
-		require.Equal(t, want, got)
-	})
-}
-
-func TestBuilderAtIndex(t *testing.T) {
-	t.Run("returns error before gloas", func(t *testing.T) {
-		stIface, _ := util.DeterministicGenesisState(t, 1)
-		native, ok := stIface.(*state_native.BeaconState)
-		require.Equal(t, true, ok)
-
-		_, err := native.BuilderAtIndex(0)
-		require.ErrorContains(t, "is not supported", err)
-	})
-
-	t.Run("returns copy", func(t *testing.T) {
-		orig := &ethpb.Builder{Balance: 42}
-		stIface, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			Builders: []*ethpb.Builder{orig},
-		})
-		require.NoError(t, err)
-
-		st := stIface.(*state_native.BeaconState)
-		got, err := st.BuilderAtIndex(0)
-		require.NoError(t, err)
-		require.Equal(t, primitives.Gwei(42), got.Balance)
-		got.Balance = 99
-		require.Equal(t, primitives.Gwei(42), orig.Balance)
-	})
-
-	t.Run("out of range returns error", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			Builders: []*ethpb.Builder{},
-		})
-		require.NoError(t, err)
-
-		st := stIface.(*state_native.BeaconState)
-		_, err = st.BuilderAtIndex(1)
-		require.ErrorContains(t, "out of range", err)
-	})
-}
-
-func TestBuilderHelpers(t *testing.T) {
-	t.Run("is active builder", func(t *testing.T) {
-		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			Builders: []*ethpb.Builder{
-				{
-					Balance:           10,
-					DepositEpoch:      0,
-					WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
-				},
-			},
-			FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1},
-		})
-		require.NoError(t, err)
-
-		active, err := st.IsActiveBuilder(0)
-		require.NoError(t, err)
-		require.Equal(t, true, active)
-
-		// Not active when withdrawable epoch is set.
-		stProto := &ethpb.BeaconStateGloas{
-			Builders: []*ethpb.Builder{
-				{
-					Balance:           10,
-					DepositEpoch:      0,
-					WithdrawableEpoch: 1,
-				},
-			},
-			FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 2},
-		}
-		stInactive, err := state_native.InitializeFromProtoGloas(stProto)
-		require.NoError(t, err)
-
-		active, err = stInactive.IsActiveBuilder(0)
-		require.NoError(t, err)
-		require.Equal(t, false, active)
-	})
-
-	t.Run("can builder cover bid", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			Builders: []*ethpb.Builder{
-				{
-					Balance:           primitives.Gwei(params.BeaconConfig().MinDepositAmount + 50),
-					DepositEpoch:      0,
-					WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
-				},
-			},
-			BuilderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{
-				{Amount: 10, BuilderIndex: 0},
-			},
-			BuilderPendingPayments: []*ethpb.BuilderPendingPayment{
-				{Withdrawal: &ethpb.BuilderPendingWithdrawal{Amount: 15, BuilderIndex: 0}},
-			},
-			FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1},
-		})
-		require.NoError(t, err)
-
-		st := stIface.(*state_native.BeaconState)
-		ok, err := st.CanBuilderCoverBid(0, 20)
-		require.NoError(t, err)
-		require.Equal(t, true, ok)
-
-		ok, err = st.CanBuilderCoverBid(0, 30)
-		require.NoError(t, err)
-		require.Equal(t, false, ok)
-	})
-}

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

@@ -1,63 +0,0 @@
-package state_native
-
-import (
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-)
-
-// SetExecutionPayloadBid sets the latest execution payload bid in the state.
-func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error {
-	if b.version < version.Gloas {
-		return errNotSupported("SetExecutionPayloadBid", b.version)
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	parentBlockHash := h.ParentBlockHash()
-	parentBlockRoot := h.ParentBlockRoot()
-	blockHash := h.BlockHash()
-	randao := h.PrevRandao()
-	blobKzgCommitmentsRoot := h.BlobKzgCommitmentsRoot()
-	feeRecipient := h.FeeRecipient()
-	b.latestExecutionPayloadBid = &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        parentBlockHash[:],
-		ParentBlockRoot:        parentBlockRoot[:],
-		BlockHash:              blockHash[:],
-		PrevRandao:             randao[:],
-		GasLimit:               h.GasLimit(),
-		BuilderIndex:           h.BuilderIndex(),
-		Slot:                   h.Slot(),
-		Value:                  h.Value(),
-		ExecutionPayment:       h.ExecutionPayment(),
-		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot[:],
-		FeeRecipient:           feeRecipient[:],
-	}
-	b.markFieldAsDirty(types.LatestExecutionPayloadBid)
-
-	return nil
-}
-
-// SetBuilderPendingPayment sets a builder pending payment at the specified index.
-func (b *BeaconState) SetBuilderPendingPayment(index primitives.Slot, payment *ethpb.BuilderPendingPayment) error {
-	if b.version < version.Gloas {
-		return errNotSupported("SetBuilderPendingPayment", b.version)
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if uint64(index) >= uint64(len(b.builderPendingPayments)) {
-		return fmt.Errorf("builder pending payments index %d out of range (len=%d)", index, len(b.builderPendingPayments))
-	}
-
-	b.builderPendingPayments[index] = ethpb.CopyBuilderPendingPayment(payment)
-
-	b.markFieldAsDirty(types.BuilderPendingPayments)
-	return nil
-}

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

@@ -1,140 +0,0 @@
-package state_native
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-type testExecutionPayloadBid struct {
-	parentBlockHash        [32]byte
-	parentBlockRoot        [32]byte
-	blockHash              [32]byte
-	prevRandao             [32]byte
-	blobKzgCommitmentsRoot [32]byte
-	feeRecipient           [20]byte
-	gasLimit               uint64
-	builderIndex           primitives.BuilderIndex
-	slot                   primitives.Slot
-	value                  primitives.Gwei
-	executionPayment       primitives.Gwei
-}
-
-func (t testExecutionPayloadBid) ParentBlockHash() [32]byte { return t.parentBlockHash }
-func (t testExecutionPayloadBid) ParentBlockRoot() [32]byte { return t.parentBlockRoot }
-func (t testExecutionPayloadBid) PrevRandao() [32]byte      { return t.prevRandao }
-func (t testExecutionPayloadBid) BlockHash() [32]byte       { return t.blockHash }
-func (t testExecutionPayloadBid) GasLimit() uint64          { return t.gasLimit }
-func (t testExecutionPayloadBid) BuilderIndex() primitives.BuilderIndex {
-	return t.builderIndex
-}
-func (t testExecutionPayloadBid) Slot() primitives.Slot  { return t.slot }
-func (t testExecutionPayloadBid) Value() primitives.Gwei { return t.value }
-func (t testExecutionPayloadBid) ExecutionPayment() primitives.Gwei {
-	return t.executionPayment
-}
-func (t testExecutionPayloadBid) BlobKzgCommitmentsRoot() [32]byte { return t.blobKzgCommitmentsRoot }
-func (t testExecutionPayloadBid) FeeRecipient() [20]byte           { return t.feeRecipient }
-func (t testExecutionPayloadBid) IsNil() bool                      { return false }
-
-func TestSetExecutionPayloadBid(t *testing.T) {
-	t.Run("previous fork returns expected error", func(t *testing.T) {
-		st := &BeaconState{version: version.Fulu}
-		err := st.SetExecutionPayloadBid(testExecutionPayloadBid{})
-		require.ErrorContains(t, "is not supported", err)
-	})
-
-	t.Run("sets bid and marks dirty", func(t *testing.T) {
-		var (
-			parentBlockHash = [32]byte(bytes.Repeat([]byte{0xAB}, 32))
-			parentBlockRoot = [32]byte(bytes.Repeat([]byte{0xCD}, 32))
-			blockHash       = [32]byte(bytes.Repeat([]byte{0xEF}, 32))
-			prevRandao      = [32]byte(bytes.Repeat([]byte{0x11}, 32))
-			blobRoot        = [32]byte(bytes.Repeat([]byte{0x22}, 32))
-			feeRecipient    [20]byte
-		)
-		copy(feeRecipient[:], bytes.Repeat([]byte{0x33}, len(feeRecipient)))
-		st := &BeaconState{
-			version:     version.Gloas,
-			dirtyFields: make(map[types.FieldIndex]bool),
-		}
-		bid := testExecutionPayloadBid{
-			parentBlockHash:        parentBlockHash,
-			parentBlockRoot:        parentBlockRoot,
-			blockHash:              blockHash,
-			prevRandao:             prevRandao,
-			blobKzgCommitmentsRoot: blobRoot,
-			feeRecipient:           feeRecipient,
-			gasLimit:               123,
-			builderIndex:           7,
-			slot:                   9,
-			value:                  11,
-			executionPayment:       22,
-		}
-
-		require.NoError(t, st.SetExecutionPayloadBid(bid))
-
-		require.NotNil(t, st.latestExecutionPayloadBid)
-		require.DeepEqual(t, parentBlockHash[:], st.latestExecutionPayloadBid.ParentBlockHash)
-		require.DeepEqual(t, parentBlockRoot[:], st.latestExecutionPayloadBid.ParentBlockRoot)
-		require.DeepEqual(t, blockHash[:], st.latestExecutionPayloadBid.BlockHash)
-		require.DeepEqual(t, prevRandao[:], st.latestExecutionPayloadBid.PrevRandao)
-		require.DeepEqual(t, blobRoot[:], st.latestExecutionPayloadBid.BlobKzgCommitmentsRoot)
-		require.DeepEqual(t, feeRecipient[:], st.latestExecutionPayloadBid.FeeRecipient)
-		require.Equal(t, uint64(123), st.latestExecutionPayloadBid.GasLimit)
-		require.Equal(t, primitives.BuilderIndex(7), st.latestExecutionPayloadBid.BuilderIndex)
-		require.Equal(t, primitives.Slot(9), st.latestExecutionPayloadBid.Slot)
-		require.Equal(t, primitives.Gwei(11), st.latestExecutionPayloadBid.Value)
-		require.Equal(t, primitives.Gwei(22), st.latestExecutionPayloadBid.ExecutionPayment)
-		require.Equal(t, true, st.dirtyFields[types.LatestExecutionPayloadBid])
-	})
-}
-
-func TestSetBuilderPendingPayment(t *testing.T) {
-	t.Run("previous fork returns expected error", func(t *testing.T) {
-		st := &BeaconState{version: version.Fulu}
-		err := st.SetBuilderPendingPayment(0, &ethpb.BuilderPendingPayment{})
-		require.ErrorContains(t, "is not supported", err)
-	})
-
-	t.Run("sets copy and marks dirty", func(t *testing.T) {
-		st := &BeaconState{
-			version:                version.Gloas,
-			dirtyFields:            make(map[types.FieldIndex]bool),
-			builderPendingPayments: make([]*ethpb.BuilderPendingPayment, 2),
-		}
-		payment := &ethpb.BuilderPendingPayment{
-			Weight: 2,
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				Amount:       99,
-				BuilderIndex: 1,
-			},
-		}
-
-		require.NoError(t, st.SetBuilderPendingPayment(1, payment))
-		require.DeepEqual(t, payment, st.builderPendingPayments[1])
-		require.Equal(t, true, st.dirtyFields[types.BuilderPendingPayments])
-
-		// Mutating the original should not affect the state copy.
-		payment.Withdrawal.Amount = 12345
-		require.Equal(t, primitives.Gwei(99), st.builderPendingPayments[1].Withdrawal.Amount)
-	})
-
-	t.Run("returns error on out of range index", func(t *testing.T) {
-		st := &BeaconState{
-			version:                version.Gloas,
-			dirtyFields:            make(map[types.FieldIndex]bool),
-			builderPendingPayments: make([]*ethpb.BuilderPendingPayment, 1),
-		}
-
-		err := st.SetBuilderPendingPayment(2, &ethpb.BuilderPendingPayment{})
-
-		require.ErrorContains(t, "out of range", err)
-		require.Equal(t, false, st.dirtyFields[types.BuilderPendingPayments])
-	})
-}

changelog/potuz_use_hashtree.md

@@ -0,0 +1,2 @@
+### Added
+- Add feature flag to use hashtree instead of gohashtre.

changelog/ttsao_add-gloas-bid-processing.md

@@ -1,3 +0,0 @@
-### Added
-
-- Add Gloas latest execution bid processing

config/features/config.go

@@ -70,6 +70,7 @@ type Flags struct {
 	DisableStakinContractCheck bool // Disables check for deposit contract when proposing blocks
 	IgnoreUnviableAttestations bool // Ignore attestations whose target state is not viable (avoids lagging-node DoS).
 
+	EnableHashtree               bool // Enables usage of the hashtree library for hashing
 	EnableVerboseSigVerification bool // EnableVerboseSigVerification specifies whether to verify individual signature if batch verification fails
 
 	PrepareAllPayloads bool // PrepareAllPayloads informs the engine to prepare a block on every slot.
@@ -237,6 +238,10 @@ func ConfigureBeaconChain(ctx *cli.Context) error {
 		logEnabled(enableFullSSZDataLogging)
 		cfg.EnableFullSSZDataLogging = true
 	}
+	if ctx.IsSet(enableHashtree.Name) {
+		logEnabled(enableHashtree)
+		cfg.EnableHashtree = true
+	}
 	cfg.EnableVerboseSigVerification = true
 	if ctx.IsSet(disableVerboseSigVerification.Name) {
 		logEnabled(disableVerboseSigVerification)

config/features/flags.go

@@ -133,6 +133,10 @@ var (
 		Name:  "enable-beacon-rest-api",
 		Usage: "(Experimental): Enables of the beacon REST API when querying a beacon node.",
 	}
+	enableHashtree = &cli.BoolFlag{
+		Name:  "enable-hashtree",
+		Usage: "(Experimental): Enables the hashtree hashing library.",
+	}
 	disableVerboseSigVerification = &cli.BoolFlag{
 		Name:  "disable-verbose-sig-verification",
 		Usage: "Disables identifying invalid signatures if batch verification fails when processing block.",
@@ -280,6 +284,7 @@ var BeaconChainFlags = combinedFlags([]cli.Flag{
 	forceHeadFlag,
 	blacklistRoots,
 	lowValcountSweep,
+	enableHashtree,
 }, deprecatedBeaconFlags, deprecatedFlags, upcomingDeprecation)
 
 func combinedFlags(flags ...[]cli.Flag) []cli.Flag {

config/params/config.go

@@ -56,12 +56,10 @@ type BeaconChainConfig struct {
 	EffectiveBalanceIncrement uint64 `yaml:"EFFECTIVE_BALANCE_INCREMENT" spec:"true"` // EffectiveBalanceIncrement is used for converting the high balance into the low balance for validators.
 
 	// Initial value constants.
-	BLSWithdrawalPrefixByte         byte                    `yaml:"BLS_WITHDRAWAL_PREFIX" spec:"true"`          // BLSWithdrawalPrefixByte is used for BLS withdrawal and it's the first byte.
-	ETH1AddressWithdrawalPrefixByte byte                    `yaml:"ETH1_ADDRESS_WITHDRAWAL_PREFIX" spec:"true"` // ETH1AddressWithdrawalPrefixByte is used for withdrawals and it's the first byte.
-	CompoundingWithdrawalPrefixByte byte                    `yaml:"COMPOUNDING_WITHDRAWAL_PREFIX" spec:"true"`  // CompoundingWithdrawalPrefixByteByte is used for compounding withdrawals and it's the first byte.
-	BuilderWithdrawalPrefixByte     byte                    `yaml:"BUILDER_WITHDRAWAL_PREFIX" spec:"true"`      // BuilderWithdrawalPrefixByte is used for builder withdrawals and it's the first byte.
-	BuilderIndexSelfBuild           primitives.BuilderIndex `yaml:"BUILDER_INDEX_SELF_BUILD" spec:"true"`       // BuilderIndexSelfBuild indicates proposer self-built payloads.
-	ZeroHash                        [32]byte                // ZeroHash is used to represent a zeroed out 32 byte array.
+	BLSWithdrawalPrefixByte         byte     `yaml:"BLS_WITHDRAWAL_PREFIX" spec:"true"`          // BLSWithdrawalPrefixByte is used for BLS withdrawal and it's the first byte.
+	ETH1AddressWithdrawalPrefixByte byte     `yaml:"ETH1_ADDRESS_WITHDRAWAL_PREFIX" spec:"true"` // ETH1AddressWithdrawalPrefixByte is used for withdrawals and it's the first byte.
+	CompoundingWithdrawalPrefixByte byte     `yaml:"COMPOUNDING_WITHDRAWAL_PREFIX" spec:"true"`  // CompoundingWithdrawalPrefixByteByte is used for compounding withdrawals and it's the first byte.
+	ZeroHash                        [32]byte // ZeroHash is used to represent a zeroed out 32 byte array.
 
 	// Time parameters constants.
 	GenesisDelay                     uint64           `yaml:"GENESIS_DELAY" spec:"true"`                   // GenesisDelay is the minimum number of seconds to delay starting the Ethereum Beacon Chain genesis. Must be at least 1 second.
@@ -141,7 +139,6 @@ type BeaconChainConfig struct {
 	DomainApplicationMask             [4]byte `yaml:"DOMAIN_APPLICATION_MASK" spec:"true"`               // DomainApplicationMask defines the BLS signature domain for application mask.
 	DomainApplicationBuilder          [4]byte `yaml:"DOMAIN_APPLICATION_BUILDER" spec:"true"`            // DomainApplicationBuilder defines the BLS signature domain for application builder.
 	DomainBLSToExecutionChange        [4]byte `yaml:"DOMAIN_BLS_TO_EXECUTION_CHANGE" spec:"true"`        // DomainBLSToExecutionChange defines the BLS signature domain to change withdrawal addresses to ETH1 prefix
-	DomainBeaconBuilder               [4]byte `yaml:"DOMAIN_BEACON_BUILDER" spec:"true"`                 // DomainBeaconBuilder defines the BLS signature domain for beacon block builder.
 
 	// Prysm constants.
 	GenesisValidatorsRoot          [32]byte        // GenesisValidatorsRoot is the root hash of the genesis validators.

config/params/mainnet_config.go

@@ -94,8 +94,6 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	BLSWithdrawalPrefixByte:         byte(0),
 	ETH1AddressWithdrawalPrefixByte: byte(1),
 	CompoundingWithdrawalPrefixByte: byte(2),
-	BuilderWithdrawalPrefixByte:     byte(3),
-	BuilderIndexSelfBuild:           primitives.BuilderIndex(math.MaxUint64),
 	ZeroHash:                        [32]byte{},
 
 	// Time parameter constants.
@@ -184,7 +182,6 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	DomainApplicationMask:             bytesutil.Uint32ToBytes4(0x00000001),
 	DomainApplicationBuilder:          bytesutil.Uint32ToBytes4(0x00000001),
 	DomainBLSToExecutionChange:        bytesutil.Uint32ToBytes4(0x0A000000),
-	DomainBeaconBuilder:               bytesutil.Uint32ToBytes4(0x1B000000),
 
 	// Prysm constants.
 	GenesisValidatorsRoot:          [32]byte{75, 54, 61, 185, 78, 40, 97, 32, 215, 110, 185, 5, 52, 15, 221, 78, 84, 191, 233, 240, 107, 243, 63, 246, 207, 90, 210, 127, 81, 27, 254, 149},

consensus-types/blocks/BUILD.bazel

@@ -14,13 +14,11 @@ go_library(
         "roblock.go",
         "rodatacolumn.go",
         "setters.go",
-        "signed_execution_bid.go",
         "types.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/consensus-types/blocks",
     visibility = ["//visibility:public"],
     deps = [
-        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -38,7 +36,6 @@ go_library(
         "//runtime/version:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
-        "@com_github_prysmaticlabs_gohashtree//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
@@ -56,17 +53,16 @@ go_test(
         "roblock_test.go",
         "rodatacolumn_test.go",
         "setters_test.go",
-        "signed_execution_bid_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
-        "//beacon-chain/core/signing:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/trie:go_default_library",
+        "//crypto/hash/htr:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
@@ -76,6 +72,5 @@ go_test(
         "//testing/require:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-        "@com_github_prysmaticlabs_gohashtree//:go_default_library",
     ],
 )

consensus-types/blocks/factory.go

@@ -641,8 +641,6 @@ func BuildSignedBeaconBlockFromExecutionPayload(blk interfaces.ReadOnlySignedBea
 			},
 			Signature: sig[:],
 		}
-	case version.Gloas:
-		return nil, errors.Wrap(errUnsupportedBeaconBlock, "gloas blocks are not supported in this function")
 	default:
 		return nil, errors.New("Block not of known type")
 	}

consensus-types/blocks/kzg.go

@@ -5,10 +5,10 @@ import (
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/container/trie"
+	"github.com/OffchainLabs/prysm/v7/crypto/hash/htr"
 	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/gohashtree"
 )
 
 const (
@@ -45,7 +45,7 @@ func VerifyKZGInclusionProof(blob ROBlob) error {
 		return errInvalidBodyRoot
 	}
 	chunks := makeChunk(blob.KzgCommitment)
-	gohashtree.HashChunks(chunks, chunks)
+	htr.HashChunks(chunks, chunks)
 	verified := trie.VerifyMerkleProof(root, chunks[0][:], blob.Index+KZGOffset, blob.CommitmentInclusionProof)
 	if !verified {
 		return errInvalidInclusionProof
@@ -182,7 +182,7 @@ func LeavesFromCommitments(commitments [][]byte) [][]byte {
 	leaves := make([][]byte, len(commitments))
 	for i, kzg := range commitments {
 		chunk := makeChunk(kzg)
-		gohashtree.HashChunks(chunk, chunk)
+		htr.HashChunks(chunk, chunk)
 		leaves[i] = chunk[0][:]
 	}
 	return leaves

consensus-types/blocks/kzg_test.go

@@ -8,10 +8,10 @@ import (
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/container/trie"
+	"github.com/OffchainLabs/prysm/v7/crypto/hash/htr"
 	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/prysmaticlabs/gohashtree"
 )
 
 func Test_MerkleProofKZGCommitment_Altair(t *testing.T) {
@@ -108,7 +108,7 @@ func Test_MerkleProofKZGCommitment(t *testing.T) {
 	require.Equal(t, true, trie.VerifyMerkleProof(root[:], commitmentsRoot[:], kzgPosition, topProof[:len(topProof)-1]))
 
 	chunk := makeChunk(kzgs[index])
-	gohashtree.HashChunks(chunk, chunk)
+	htr.HashChunks(chunk, chunk)
 	require.Equal(t, true, trie.VerifyMerkleProof(root[:], chunk[0][:], uint64(index+KZGOffset), proof))
 }
 

consensus-types/blocks/signed_execution_bid.go

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

consensus-types/blocks/signed_execution_bid_test.go

@@ -1,127 +0,0 @@
-package blocks_test
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/assert"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func validExecutionPayloadBid() *ethpb.ExecutionPayloadBid {
-	return &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        bytes.Repeat([]byte{0x01}, 32),
-		ParentBlockRoot:        bytes.Repeat([]byte{0x02}, 32),
-		BlockHash:              bytes.Repeat([]byte{0x03}, 32),
-		PrevRandao:             bytes.Repeat([]byte{0x04}, 32),
-		GasLimit:               123,
-		BuilderIndex:           5,
-		Slot:                   6,
-		Value:                  7,
-		ExecutionPayment:       8,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x05}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x06}, 20),
-	}
-}
-
-func TestWrappedROExecutionPayloadBid(t *testing.T) {
-	t.Run("returns error on invalid lengths", func(t *testing.T) {
-		testCases := []struct {
-			name   string
-			mutate func(*ethpb.ExecutionPayloadBid)
-		}{
-			{
-				name:   "parent block hash",
-				mutate: func(b *ethpb.ExecutionPayloadBid) { b.ParentBlockHash = []byte{0x01} },
-			},
-			{
-				name:   "parent block root",
-				mutate: func(b *ethpb.ExecutionPayloadBid) { b.ParentBlockRoot = []byte{0x02} },
-			},
-			{
-				name:   "block hash",
-				mutate: func(b *ethpb.ExecutionPayloadBid) { b.BlockHash = []byte{0x03} },
-			},
-			{
-				name:   "prev randao",
-				mutate: func(b *ethpb.ExecutionPayloadBid) { b.PrevRandao = []byte{0x04} },
-			},
-			{
-				name:   "blob kzg commitments root",
-				mutate: func(b *ethpb.ExecutionPayloadBid) { b.BlobKzgCommitmentsRoot = []byte{0x05} },
-			},
-			{
-				name:   "fee recipient",
-				mutate: func(b *ethpb.ExecutionPayloadBid) { b.FeeRecipient = []byte{0x06} },
-			},
-		}
-
-		for _, tc := range testCases {
-			t.Run(tc.name, func(t *testing.T) {
-				invalid := validExecutionPayloadBid()
-				tc.mutate(invalid)
-
-				_, err := blocks.WrappedROExecutionPayloadBid(invalid)
-				require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
-			})
-		}
-	})
-
-	t.Run("wraps and exposes fields", func(t *testing.T) {
-		bid := validExecutionPayloadBid()
-		wrapped, err := blocks.WrappedROExecutionPayloadBid(bid)
-		require.NoError(t, err)
-
-		require.Equal(t, primitives.BuilderIndex(5), wrapped.BuilderIndex())
-		require.Equal(t, primitives.Slot(6), wrapped.Slot())
-		require.Equal(t, primitives.Gwei(7), wrapped.Value())
-		require.Equal(t, primitives.Gwei(8), wrapped.ExecutionPayment())
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x01}, 32)), wrapped.ParentBlockHash())
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x02}, 32)), wrapped.ParentBlockRoot())
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x03}, 32)), wrapped.BlockHash())
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x04}, 32)), wrapped.PrevRandao())
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x05}, 32)), wrapped.BlobKzgCommitmentsRoot())
-		assert.DeepEqual(t, [20]byte(bytes.Repeat([]byte{0x06}, 20)), wrapped.FeeRecipient())
-	})
-}
-
-func TestWrappedROSignedExecutionPayloadBid(t *testing.T) {
-	t.Run("returns error for invalid signature length", func(t *testing.T) {
-		signed := &ethpb.SignedExecutionPayloadBid{
-			Message:   validExecutionPayloadBid(),
-			Signature: bytes.Repeat([]byte{0xAA}, 95),
-		}
-		_, err := blocks.WrappedROSignedExecutionPayloadBid(signed)
-		require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
-	})
-
-	t.Run("wraps and provides bid/signing data", func(t *testing.T) {
-		sig := bytes.Repeat([]byte{0xAB}, 96)
-		signed := &ethpb.SignedExecutionPayloadBid{
-			Message:   validExecutionPayloadBid(),
-			Signature: sig,
-		}
-
-		wrapped, err := blocks.WrappedROSignedExecutionPayloadBid(signed)
-		require.NoError(t, err)
-
-		bid, err := wrapped.Bid()
-		require.NoError(t, err)
-		require.Equal(t, primitives.Gwei(8), bid.ExecutionPayment())
-
-		gotSig := wrapped.Signature()
-		assert.DeepEqual(t, [96]byte(sig), gotSig)
-
-		domain := bytes.Repeat([]byte{0xCC}, 32)
-		wantRoot, err := signing.ComputeSigningRoot(signed.Message, domain)
-		require.NoError(t, err)
-		gotRoot, err := wrapped.SigningRoot(domain)
-		require.NoError(t, err)
-		require.Equal(t, wantRoot, gotRoot)
-	})
-}

consensus-types/interfaces/BUILD.bazel

@@ -6,7 +6,6 @@ go_library(
         "beacon_block.go",
         "error.go",
         "light_client.go",
-        "signed_execution_payload_bid.go",
         "utils.go",
         "validator.go",
     ],

consensus-types/interfaces/signed_execution_payload_bid.go

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

crypto/hash/htr/BUILD.bazel

@@ -5,7 +5,12 @@ go_library(
     srcs = ["hashtree.go"],
     importpath = "github.com/OffchainLabs/prysm/v7/crypto/hash/htr",
     visibility = ["//visibility:public"],
-    deps = ["@com_github_prysmaticlabs_gohashtree//:go_default_library"],
+    deps = [
+        "//config/features:go_default_library",
+        "@com_github_offchainlabs_hashtree//:go_default_library",
+        "@com_github_prysmaticlabs_gohashtree//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
 )
 
 go_test(
@@ -13,5 +18,8 @@ go_test(
     size = "small",
     srcs = ["hashtree_test.go"],
     embed = [":go_default_library"],
-    deps = ["//testing/require:go_default_library"],
+    deps = [
+        "//config/features:go_default_library",
+        "//testing/require:go_default_library",
+    ],
 )

crypto/hash/htr/hashtree.go

@@ -4,14 +4,38 @@ import (
 	"runtime"
 	"sync"
 
+	"github.com/OffchainLabs/hashtree"
+	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/prysmaticlabs/gohashtree"
+	log "github.com/sirupsen/logrus"
 )
 
 const minSliceSizeToParallelize = 5000
 
+// Hash hashes chunks pairwise into digests using the configured hashing library.
+// It performs input validation (odd chunks, digest length).
+func Hash(digests, chunks [][32]byte) error {
+	if features.Get().EnableHashtree {
+		return hashtree.Hash(digests, chunks)
+	}
+	return gohashtree.Hash(digests, chunks)
+}
+
+// HashChunks hashes chunks pairwise into digests without error checking.
+// The caller must ensure inputs are valid (even chunks, sufficient digest space).
+func HashChunks(digests, chunks [][32]byte) {
+	if features.Get().EnableHashtree {
+		if err := hashtree.Hash(digests, chunks); err != nil {
+			log.WithError(err).Error("Could not hash chunks")
+		}
+	} else {
+		gohashtree.HashChunks(digests, chunks)
+	}
+}
+
 func hashParallel(inputList [][32]byte, outputList [][32]byte, wg *sync.WaitGroup) {
 	defer wg.Done()
-	err := gohashtree.Hash(outputList, inputList)
+	err := Hash(outputList, inputList)
 	if err != nil {
 		panic(err) // lint:nopanic -- This should never panic.
 	}
@@ -25,7 +49,7 @@ func hashParallel(inputList [][32]byte, outputList [][32]byte, wg *sync.WaitGrou
 func VectorizedSha256(inputList [][32]byte) [][32]byte {
 	outputList := make([][32]byte, len(inputList)/2)
 	if len(inputList) < minSliceSizeToParallelize {
-		err := gohashtree.Hash(outputList, inputList)
+		err := Hash(outputList, inputList)
 		if err != nil {
 			panic(err) // lint:nopanic -- This should never panic.
 		}
@@ -38,7 +62,7 @@ func VectorizedSha256(inputList [][32]byte) [][32]byte {
 	for j := range n {
 		go hashParallel(inputList[j*2*groupSize:(j+1)*2*groupSize], outputList[j*groupSize:], &wg)
 	}
-	err := gohashtree.Hash(outputList[n*groupSize:], inputList[n*2*groupSize:])
+	err := Hash(outputList[n*groupSize:], inputList[n*2*groupSize:])
 	if err != nil {
 		panic(err) // lint:nopanic -- This should never panic.
 	}

crypto/hash/htr/hashtree_test.go

@@ -4,6 +4,7 @@ import (
 	"sync"
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
 )
 
@@ -23,3 +24,25 @@ func Test_VectorizedSha256(t *testing.T) {
 		require.Equal(t, r, hash2[i])
 	}
 }
+
+func Test_VectorizedSha256_hashtree_enabled(t *testing.T) {
+	resetCfg := features.InitWithReset(&features.Flags{
+		EnableHashtree: true,
+	})
+	defer resetCfg()
+
+	largeSlice := make([][32]byte, 32*minSliceSizeToParallelize)
+	secondLargeSlice := make([][32]byte, 32*minSliceSizeToParallelize)
+	hash1 := make([][32]byte, 16*minSliceSizeToParallelize)
+	wg := sync.WaitGroup{}
+	wg.Go(func() {
+		tempHash := VectorizedSha256(largeSlice)
+		copy(hash1, tempHash)
+	})
+	wg.Wait()
+	hash2 := VectorizedSha256(secondLargeSlice)
+	require.Equal(t, len(hash1), len(hash2))
+	for i, r := range hash1 {
+		require.Equal(t, r, hash2[i])
+	}
+}

deps.bzl

@@ -2449,6 +2449,15 @@ def prysm_deps():
         sum = "h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY=",
         version = "v1.4.11",
     )
+    go_repository(
+        name = "com_github_offchainlabs_hashtree",
+        build_file_generation = "off",
+        importpath = "github.com/OffchainLabs/hashtree",
+        patch_args = ["-p1"],
+        patches = ["//third_party:com_github_offchainlabs_hashtree.patch"],
+        sum = "h1:R6DAjgAUwwfgji3jEI4WUxtZ3eJ+FbRHjW21UPMBJyo=",
+        version = "v0.2.2",
+    )
     go_repository(
         name = "com_github_oklog_oklog",
         importpath = "github.com/oklog/oklog",

encoding/ssz/BUILD.bazel

@@ -21,7 +21,6 @@ go_library(
         "@com_github_minio_sha256_simd//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-        "@com_github_prysmaticlabs_gohashtree//:go_default_library",
     ],
 )
 

encoding/ssz/merkleize.go

@@ -6,7 +6,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/container/trie"
 	"github.com/OffchainLabs/prysm/v7/crypto/hash/htr"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/gohashtree"
 )
 
 var errInvalidNilSlice = errors.New("invalid empty slice")
@@ -182,10 +181,10 @@ func MerkleizeListSSZ[T Hashable](elements []T, limit uint64) ([32]byte, error)
 	chunks := make([][32]byte, 2)
 	chunks[0] = body
 	binary.LittleEndian.PutUint64(chunks[1][:], uint64(len(elements)))
-	if err := gohashtree.Hash(chunks, chunks); err != nil {
+	if err = htr.Hash(chunks, chunks); err != nil {
 		return [32]byte{}, err
 	}
-	return chunks[0], err
+	return chunks[0], nil
 }
 
 // MerkleizeByteSliceSSZ hashes a byteslice by chunkifying it and returning the

go.mod

@@ -6,6 +6,7 @@ require (
 	github.com/MariusVanDerWijden/FuzzyVM v0.0.0-20240516070431-7828990cad7d
 	github.com/MariusVanDerWijden/tx-fuzz v1.4.0
 	github.com/OffchainLabs/go-bitfield v0.0.0-20251031151322-f427d04d8506
+	github.com/OffchainLabs/hashtree v0.2.3
 	github.com/aristanetworks/goarista v0.0.0-20200805130819-fd197cf57d96
 	github.com/bazelbuild/rules_go v0.23.2
 	github.com/btcsuite/btcd/btcec/v2 v2.3.4

go.sum

@@ -59,6 +59,8 @@ github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERo
 github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
 github.com/OffchainLabs/go-bitfield v0.0.0-20251031151322-f427d04d8506 h1:d/SJkN8/9Ca+1YmuDiUJxAiV4w/a9S8NcsG7GMQSrVI=
 github.com/OffchainLabs/go-bitfield v0.0.0-20251031151322-f427d04d8506/go.mod h1:6TZI4FU6zT8x6ZfWa1J8YQ2NgW0wLV/W3fHRca8ISBo=
+github.com/OffchainLabs/hashtree v0.2.3 h1:nM8dBAQZzHLzzM14FaAHXnHTAXZIst69v5xWuS48y/c=
+github.com/OffchainLabs/hashtree v0.2.3/go.mod h1:b07+cRZs+eAR8TR57CB9TQlt5Gnl/06Xs76xt/1wq0M=
 github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
 github.com/Shopify/sarama v1.26.1/go.mod h1:NbSGBSSndYaIhRcBtY9V0U7AyH+x71bG668AuWys/yU=
 github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=

proto/prysm/v1alpha1/cloners.go

@@ -189,28 +189,3 @@ func copyBeaconBlockBodyGloas(body *BeaconBlockBodyGloas) *BeaconBlockBodyGloas
 
 	return copied
 }
-
-// CopyBuilderPendingPayment creates a deep copy of a builder pending payment.
-func CopyBuilderPendingPayment(original *BuilderPendingPayment) *BuilderPendingPayment {
-	if original == nil {
-		return nil
-	}
-
-	return &BuilderPendingPayment{
-		Weight:     original.Weight,
-		Withdrawal: CopyBuilderPendingWithdrawal(original.Withdrawal),
-	}
-}
-
-// CopyBuilderPendingWithdrawal creates a deep copy of a builder pending withdrawal.
-func CopyBuilderPendingWithdrawal(original *BuilderPendingWithdrawal) *BuilderPendingWithdrawal {
-	if original == nil {
-		return nil
-	}
-
-	return &BuilderPendingWithdrawal{
-		FeeRecipient: bytesutil.SafeCopyBytes(original.FeeRecipient),
-		Amount:       original.Amount,
-		BuilderIndex: original.BuilderIndex,
-	}
-}

proto/prysm/v1alpha1/cloners_test.go

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

testing/spectest/mainnet/BUILD.bazel

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

testing/spectest/mainnet/gloas__operations__execution_payload_header_test.go

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

testing/spectest/minimal/BUILD.bazel

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

testing/spectest/minimal/gloas__operations__execution_payload_bid_test.go

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

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

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

testing/spectest/shared/common/operations/execution_payload_bid.go

@@ -1,47 +0,0 @@
-package operations
-
-import (
-	"context"
-	"path"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/utils"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
-	"github.com/golang/snappy"
-)
-
-func runExecutionPayloadBidTest(t *testing.T, config string, fork string, objName string, block blockWithSSZObject, sszToState SSZToState, operationFn BlockOperation) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/"+objName+"/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/"+objName+"/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			if folder.Name() != "process_execution_payload_bid_self_build_non_zero_value" {
-				t.Skip("skipping other tests for now")
-			}
-			helpers.ClearCache()
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			blockFile, err := util.BazelFileBytes(folderPath, "block.ssz_snappy")
-			require.NoError(t, err)
-			blockSSZ, err := snappy.Decode(nil /* dst */, blockFile)
-			require.NoError(t, err, "Failed to decompress")
-			blk, err := block(blockSSZ)
-			require.NoError(t, err)
-			RunBlockOperationTest(t, folderPath, blk, sszToState, operationFn)
-		})
-	}
-}
-
-func RunExecutionPayloadBidTest(t *testing.T, config string, fork string, block blockWithSSZObject, sszToState SSZToState) {
-	runExecutionPayloadBidTest(t, config, fork, "execution_payload_bid", block, sszToState, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-		err := gloas.ProcessExecutionPayloadBid(s, b.Block())
-		return s, err
-	})
-}

testing/spectest/shared/gloas/operations/BUILD.bazel

@@ -1,21 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    testonly = True,
-    srcs = [
-        "execution_payload_bid.go",
-        "helpers.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
-        "//testing/spectest/shared/common/operations:go_default_library",
-    ],
-)

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

@@ -1,23 +0,0 @@
-package operations
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	common "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/common/operations"
-)
-
-func blockWithSignedExecutionPayloadBid(blockSSZ []byte) (interfaces.SignedBeaconBlock, error) {
-	var block ethpb.BeaconBlockGloas
-	if err := block.UnmarshalSSZ(blockSSZ); err != nil {
-		return nil, err
-	}
-	return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockGloas{Block: &block})
-}
-
-func RunExecutionPayloadBidTest(t *testing.T, config string) {
-	common.RunExecutionPayloadBidTest(t, config, version.String(version.Gloas), blockWithSignedExecutionPayloadBid, sszToState)
-}

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

@@ -1,15 +0,0 @@
-package operations
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-func sszToState(b []byte) (state.BeaconState, error) {
-	base := &ethpb.BeaconStateGloas{}
-	if err := base.UnmarshalSSZ(b); err != nil {
-		return nil, err
-	}
-	return state_native.InitializeFromProtoGloas(base)
-}

third_party/com_github_offchainlabs_hashtree.patch

@@ -0,0 +1,90 @@
+diff -urN a/BUILD.bazel b/BUILD.bazel
+--- a/BUILD.bazel	1969-12-31 18:00:00.000000000 -0600
++++ b/BUILD.bazel	2025-01-05 12:00:00.000000000 -0600
+@@ -0,0 +1,86 @@
++load("@io_bazel_rules_go//go:def.bzl", "go_library")
++
++go_library(
++    name = "go_default_library",
++    srcs = [
++        "bindings.go",
++        "sha256_1_generic.go",
++    ] + select({
++        "@io_bazel_rules_go//go/platform:linux_amd64": [
++            "bindings_amd64.go",
++            "wrapper_linux_amd64.s",
++            ":hashtree_amd64_syso",
++        ],
++        "@io_bazel_rules_go//go/platform:windows_amd64": [
++            "bindings_amd64.go",
++            "wrapper_windows_amd64.s",
++            ":hashtree_amd64_syso",
++        ],
++        "@io_bazel_rules_go//go/platform:linux_arm64": [
++            "bindings_arm64.go",
++            "wrapper_arm64.s",
++            ":hashtree_arm64_syso",
++        ],
++        "@io_bazel_rules_go//go/platform:darwin_arm64": [
++            "bindings_arm64.go",
++            "wrapper_arm64.s",
++            ":hashtree_arm64_syso",
++        ],
++        "@io_bazel_rules_go//go/platform:darwin_amd64": [
++            "bindings_darwin_amd64.go",
++        ],
++        "//conditions:default": [],
++    }),
++    importpath = "github.com/OffchainLabs/hashtree",
++    visibility = ["//visibility:public"],
++    deps = ["@com_github_klauspost_cpuid_v2//:go_default_library"],
++)
++
++genrule(
++    name = "hashtree_arm64_syso",
++    srcs = [":hashtree_arm64"],
++    outs = ["hashtree_arm64.syso"],
++    cmd = "cp $(location :hashtree_arm64) $@",
++)
++
++genrule(
++    name = "hashtree_amd64_syso",
++    srcs = [":hashtree_amd64"],
++    outs = ["hashtree_amd64.syso"],
++    cmd = "cp $(location :hashtree_amd64) $@",
++)
++
++cc_library(
++    name = "hashtree_arm64",
++    srcs = [
++        "src/hashtree.c",
++        "src/sha256_generic.c",
++        "src/sha256_armv8_crypto.S",
++        "src/sha256_armv8_neon_x1.S",
++        "src/sha256_armv8_neon_x4.S",
++    ],
++    hdrs = ["src/hashtree.h"],
++    copts = ["-O3", "-Wall"],
++    linkstatic = True,
++    strip_include_prefix = "src",
++    visibility = ["//visibility:public"],
++)
++
++cc_library(
++    name = "hashtree_amd64",
++    srcs = [
++        "src/hashtree.c",
++        "src/sha256_generic.c",
++        "src/sha256_avx_x1.S",
++        "src/sha256_avx_x4.S",
++        "src/sha256_avx_x8.S",
++        "src/sha256_avx_x16.S",
++        "src/sha256_shani.S",
++        "src/sha256_sse_x1.S",
++    ],
++    hdrs = ["src/hashtree.h"],
++    copts = ["-O3", "-Wall", "-fno-integrated-as"],
++    linkstatic = True,
++    strip_include_prefix = "src",
++    visibility = ["//visibility:public"],
++)