Add gloas payload header processing

Add Gloas execution payload header processing and state integration Implement Gloas fork support in consensus-types/blocks Add Gloas state fields to beacon state implementation
2026-01-09 15:37:56 -05:00 · 2025-08-18 06:58:42 -07:00
parent c96d188468
commit 40a2e534e8
32 changed files with 1895 additions and 5 deletions
--- a/beacon-chain/core/gloas/BUILD.bazel
+++ b/beacon-chain/core/gloas/BUILD.bazel
@@ -0,0 +1,46 @@
+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",
+        "//consensus-types/primitives: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",
+    ],
+)
--- a/beacon-chain/core/gloas/bid.go
+++ b/beacon-chain/core/gloas/bid.go
@@ -0,0 +1,197 @@
+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
+}
--- a/beacon-chain/core/gloas/bid_test.go
+++ b/beacon-chain/core/gloas/bid_test.go
@@ -0,0 +1,628 @@
+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)
+}
--- a/beacon-chain/rpc/eth/config/handlers_test.go
+++ b/beacon-chain/rpc/eth/config/handlers_test.go
@@ -168,6 +168,8 @@ 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'})
@@ -190,6 +192,9 @@ 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
@@ -205,7 +210,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, 175, len(data))
+	assert.Equal(t, 178, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -419,8 +424,14 @@ 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":
--- a/beacon-chain/state/BUILD.bazel
+++ b/beacon-chain/state/BUILD.bazel
@@ -5,6 +5,7 @@ go_library(
    srcs = [
        "error.go",
        "interfaces.go",
+        "interfaces_gloas.go",
        "prometheus.go",
    ],
    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/state",
--- a/beacon-chain/state/interfaces.go
+++ b/beacon-chain/state/interfaces.go
@@ -63,6 +63,7 @@ type ReadOnlyBeaconState interface {
 	ReadOnlyDeposits
 	ReadOnlyConsolidations
 	ReadOnlyProposerLookahead
+	readOnlyGloasFields
 	ToProtoUnsafe() any
 	ToProto() any
 	GenesisTime() time.Time
@@ -98,6 +99,7 @@ type WriteOnlyBeaconState interface {
 	WriteOnlyWithdrawals
 	WriteOnlyDeposits
 	WriteOnlyProposerLookahead
+	writeOnlyGloasFields
 	SetGenesisTime(val time.Time) error
 	SetGenesisValidatorsRoot(val []byte) error
 	SetSlot(val primitives.Slot) error
--- a/beacon-chain/state/interfaces_gloas.go
+++ b/beacon-chain/state/interfaces_gloas.go
@@ -0,0 +1,19 @@
+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)
+}
--- a/beacon-chain/state/state-native/BUILD.bazel
+++ b/beacon-chain/state/state-native/BUILD.bazel
@@ -14,6 +14,7 @@ go_library(
        "getters_deposits.go",
        "getters_eth1.go",
        "getters_exit.go",
+        "getters_gloas.go",
        "getters_misc.go",
        "getters_participation.go",
        "getters_payload_header.go",
@@ -36,6 +37,7 @@ 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",
@@ -97,6 +99,7 @@ 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",
@@ -114,6 +117,7 @@ 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",
--- a/beacon-chain/state/state-native/getters_gloas.go
+++ b/beacon-chain/state/state-native/getters_gloas.go
@@ -0,0 +1,128 @@
+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
+}
--- a/beacon-chain/state/state-native/getters_gloas_test.go
+++ b/beacon-chain/state/state-native/getters_gloas_test.go
@@ -0,0 +1,149 @@
+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)
+	})
+}
--- a/beacon-chain/state/state-native/setters_gloas.go
+++ b/beacon-chain/state/state-native/setters_gloas.go
@@ -0,0 +1,57 @@
+package state_native
+
+import (
+	"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()
+
+	b.builderPendingPayments[index] = ethpb.CopyBuilderPendingPayment(payment)
+
+	b.markFieldAsDirty(types.BuilderPendingPayments)
+	return nil
+}
--- a/beacon-chain/state/state-native/setters_gloas_test.go
+++ b/beacon-chain/state/state-native/setters_gloas_test.go
@@ -0,0 +1,127 @@
+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)
+	})
+}
--- a/changelog/ttsao_add-gloas-bid-processing.md
+++ b/changelog/ttsao_add-gloas-bid-processing.md
@@ -0,0 +1,3 @@
+### Added
+
+- Add Gloas latest execution bid processing
--- a/config/params/config.go
+++ b/config/params/config.go
@@ -56,10 +56,12 @@ 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.
-	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.
+	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.

 	// 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.
@@ -139,6 +141,7 @@ 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.
--- a/config/params/mainnet_config.go
+++ b/config/params/mainnet_config.go
@@ -94,6 +94,8 @@ 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.
@@ -182,6 +184,7 @@ 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},
--- a/consensus-types/blocks/BUILD.bazel
+++ b/consensus-types/blocks/BUILD.bazel
@@ -14,11 +14,13 @@ 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",
@@ -54,9 +56,11 @@ 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",
--- a/consensus-types/blocks/factory.go
+++ b/consensus-types/blocks/factory.go
@@ -641,6 +641,8 @@ 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")
 	}
--- a/consensus-types/blocks/signed_execution_bid.go
+++ b/consensus-types/blocks/signed_execution_bid.go
@@ -0,0 +1,140 @@
+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.BlobKzgCommitmentsRoot) != 32 {
+		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)
+}
--- a/consensus-types/blocks/signed_execution_bid_test.go
+++ b/consensus-types/blocks/signed_execution_bid_test.go
@@ -0,0 +1,92 @@
+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) {
+		invalid := validExecutionPayloadBid()
+		invalid.ParentBlockHash = []byte{0x01}
+		_, 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.ValidatorIndex(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)
+	})
+}
--- a/consensus-types/interfaces/BUILD.bazel
+++ b/consensus-types/interfaces/BUILD.bazel
@@ -6,6 +6,7 @@ go_library(
        "beacon_block.go",
        "error.go",
        "light_client.go",
+        "signed_execution_payload_bid.go",
        "utils.go",
        "validator.go",
    ],
--- a/consensus-types/interfaces/signed_execution_payload_bid.go
+++ b/consensus-types/interfaces/signed_execution_payload_bid.go
@@ -0,0 +1,28 @@
+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
+}
--- a/proto/prysm/v1alpha1/cloners.go
+++ b/proto/prysm/v1alpha1/cloners.go
@@ -189,3 +189,28 @@ 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,
+	}
+}
--- a/proto/prysm/v1alpha1/cloners_test.go
+++ b/proto/prysm/v1alpha1/cloners_test.go
@@ -1246,3 +1246,89 @@ 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)
+		}
+	})
+}
--- a/testing/spectest/mainnet/BUILD.bazel
+++ b/testing/spectest/mainnet/BUILD.bazel
@@ -200,6 +200,7 @@ 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",
@@ -278,6 +279,7 @@ 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",
--- a/testing/spectest/mainnet/gloasoperationsexecution_payload_header_test.go
+++ b/testing/spectest/mainnet/gloasoperationsexecution_payload_header_test.go
@@ -0,0 +1,11 @@
+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")
+}
--- a/testing/spectest/minimal/BUILD.bazel
+++ b/testing/spectest/minimal/BUILD.bazel
@@ -206,6 +206,7 @@ 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",
@@ -288,6 +289,7 @@ 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",
--- a/testing/spectest/minimal/gloasoperationsexecution_payload_bid_test.go
+++ b/testing/spectest/minimal/gloasoperationsexecution_payload_bid_test.go
@@ -0,0 +1,11 @@
+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")
+}
--- a/testing/spectest/shared/common/operations/BUILD.bazel
+++ b/testing/spectest/shared/common/operations/BUILD.bazel
@@ -12,6 +12,7 @@ go_library(
        "deposit.go",
        "deposit_request.go",
        "execution_payload.go",
+        "execution_payload_bid.go",
        "proposer_slashing.go",
        "slashing.go",
        "sync_aggregate.go",
@@ -26,6 +27,7 @@ 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",
--- a/testing/spectest/shared/common/operations/execution_payload_bid.go
+++ b/testing/spectest/shared/common/operations/execution_payload_bid.go
@@ -0,0 +1,47 @@
+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
+	})
+}
--- a/testing/spectest/shared/gloas/operations/BUILD.bazel
+++ b/testing/spectest/shared/gloas/operations/BUILD.bazel
@@ -0,0 +1,21 @@
+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",
+    ],
+)
--- a/testing/spectest/shared/gloas/operations/execution_payload_bid.go
+++ b/testing/spectest/shared/gloas/operations/execution_payload_bid.go
@@ -0,0 +1,23 @@
+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)
+}
--- a/testing/spectest/shared/gloas/operations/helpers.go
+++ b/testing/spectest/shared/gloas/operations/helpers.go
@@ -0,0 +1,15 @@
+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)
+}