gloas support for debug/beacon/state/ api

Add deposit request

api/server/structs/BUILD.bazel

@@ -9,6 +9,7 @@ go_library(
         "conversions_blob.go",
         "conversions_block.go",
         "conversions_block_execution.go",
+        "conversions_gloas.go",
         "conversions_lightclient.go",
         "conversions_state.go",
         "endpoints_beacon.go",
@@ -57,10 +58,12 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//consensus-types/blocks:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
     ],

api/server/structs/conversions_gloas.go

@@ -0,0 +1,81 @@
+package structs
+
+import (
+	"fmt"
+
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+func ROExecutionPayloadBidFromConsensus(b interfaces.ROExecutionPayloadBid) *ExecutionPayloadBid {
+	pbh := b.ParentBlockHash()
+	pbr := b.ParentBlockRoot()
+	bh := b.BlockHash()
+	pr := b.PrevRandao()
+	fr := b.FeeRecipient()
+	bcr := b.BlobKzgCommitmentsRoot()
+	return &ExecutionPayloadBid{
+		ParentBlockHash:        hexutil.Encode(pbh[:]),
+		ParentBlockRoot:        hexutil.Encode(pbr[:]),
+		BlockHash:              hexutil.Encode(bh[:]),
+		PrevRandao:             hexutil.Encode(pr[:]),
+		FeeRecipient:           hexutil.Encode(fr[:]),
+		GasLimit:               fmt.Sprintf("%d", b.GasLimit()),
+		BuilderIndex:           fmt.Sprintf("%d", b.BuilderIndex()),
+		Slot:                   fmt.Sprintf("%d", b.Slot()),
+		Value:                  fmt.Sprintf("%d", b.Value()),
+		ExecutionPayment:       fmt.Sprintf("%d", b.ExecutionPayment()),
+		BlobKzgCommitmentsRoot: hexutil.Encode(bcr[:]),
+	}
+}
+
+func BuildersFromConsensus(builders []*ethpb.Builder) []*Builder {
+	newBuilders := make([]*Builder, len(builders))
+	for i, b := range builders {
+		newBuilders[i] = BuilderFromConsensus(b)
+	}
+	return newBuilders
+}
+
+func BuilderFromConsensus(b *ethpb.Builder) *Builder {
+	return &Builder{
+		Pubkey:            hexutil.Encode(b.Pubkey),
+		Version:           hexutil.Encode(b.Version),
+		ExecutionAddress:  hexutil.Encode(b.ExecutionAddress),
+		Balance:           fmt.Sprintf("%d", b.Balance),
+		DepositEpoch:      fmt.Sprintf("%d", b.DepositEpoch),
+		WithdrawableEpoch: fmt.Sprintf("%d", b.WithdrawableEpoch),
+	}
+}
+
+func BuilderPendingPaymentsFromConsensus(payments []*ethpb.BuilderPendingPayment) []*BuilderPendingPayment {
+	newPayments := make([]*BuilderPendingPayment, len(payments))
+	for i, p := range payments {
+		newPayments[i] = BuilderPendingPaymentFromConsensus(p)
+	}
+	return newPayments
+}
+
+func BuilderPendingPaymentFromConsensus(p *ethpb.BuilderPendingPayment) *BuilderPendingPayment {
+	return &BuilderPendingPayment{
+		Weight:     fmt.Sprintf("%d", p.Weight),
+		Withdrawal: BuilderPendingWithdrawalFromConsensus(p.Withdrawal),
+	}
+}
+
+func BuilderPendingWithdrawalsFromConsensus(withdrawals []*ethpb.BuilderPendingWithdrawal) []*BuilderPendingWithdrawal {
+	newWithdrawals := make([]*BuilderPendingWithdrawal, len(withdrawals))
+	for i, w := range withdrawals {
+		newWithdrawals[i] = BuilderPendingWithdrawalFromConsensus(w)
+	}
+	return newWithdrawals
+}
+
+func BuilderPendingWithdrawalFromConsensus(w *ethpb.BuilderPendingWithdrawal) *BuilderPendingWithdrawal {
+	return &BuilderPendingWithdrawal{
+		FeeRecipient: hexutil.Encode(w.FeeRecipient),
+		Amount:       fmt.Sprintf("%d", w.Amount),
+		BuilderIndex: fmt.Sprintf("%d", w.BuilderIndex),
+	}
+}

api/server/structs/conversions_state.go

@@ -972,3 +972,223 @@ func BeaconStateFuluFromConsensus(st beaconState.BeaconState) (*BeaconStateFulu,
 		ProposerLookahead:             lookahead,
 	}, nil
 }
+
+// ----------------------------------------------------------------------------
+// Gloas
+// ----------------------------------------------------------------------------
+
+func BeaconStateGloasFromConsensus(st beaconState.BeaconState) (*BeaconStateGloas, error) {
+	srcBr := st.BlockRoots()
+	br := make([]string, len(srcBr))
+	for i, r := range srcBr {
+		br[i] = hexutil.Encode(r)
+	}
+	srcSr := st.StateRoots()
+	sr := make([]string, len(srcSr))
+	for i, r := range srcSr {
+		sr[i] = hexutil.Encode(r)
+	}
+	srcHr := st.HistoricalRoots()
+	hr := make([]string, len(srcHr))
+	for i, r := range srcHr {
+		hr[i] = hexutil.Encode(r)
+	}
+	srcVotes := st.Eth1DataVotes()
+	votes := make([]*Eth1Data, len(srcVotes))
+	for i, e := range srcVotes {
+		votes[i] = Eth1DataFromConsensus(e)
+	}
+	srcVals := st.Validators()
+	vals := make([]*Validator, len(srcVals))
+	for i, v := range srcVals {
+		vals[i] = ValidatorFromConsensus(v)
+	}
+	srcBals := st.Balances()
+	bals := make([]string, len(srcBals))
+	for i, b := range srcBals {
+		bals[i] = fmt.Sprintf("%d", b)
+	}
+	srcRm := st.RandaoMixes()
+	rm := make([]string, len(srcRm))
+	for i, m := range srcRm {
+		rm[i] = hexutil.Encode(m)
+	}
+	srcSlashings := st.Slashings()
+	slashings := make([]string, len(srcSlashings))
+	for i, s := range srcSlashings {
+		slashings[i] = fmt.Sprintf("%d", s)
+	}
+	srcPrevPart, err := st.PreviousEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	prevPart := make([]string, len(srcPrevPart))
+	for i, p := range srcPrevPart {
+		prevPart[i] = fmt.Sprintf("%d", p)
+	}
+	srcCurrPart, err := st.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	currPart := make([]string, len(srcCurrPart))
+	for i, p := range srcCurrPart {
+		currPart[i] = fmt.Sprintf("%d", p)
+	}
+	srcIs, err := st.InactivityScores()
+	if err != nil {
+		return nil, err
+	}
+	is := make([]string, len(srcIs))
+	for i, s := range srcIs {
+		is[i] = fmt.Sprintf("%d", s)
+	}
+	currSc, err := st.CurrentSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	nextSc, err := st.NextSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	srcHs, err := st.HistoricalSummaries()
+	if err != nil {
+		return nil, err
+	}
+	hs := make([]*HistoricalSummary, len(srcHs))
+	for i, s := range srcHs {
+		hs[i] = HistoricalSummaryFromConsensus(s)
+	}
+	nwi, err := st.NextWithdrawalIndex()
+	if err != nil {
+		return nil, err
+	}
+	nwvi, err := st.NextWithdrawalValidatorIndex()
+	if err != nil {
+		return nil, err
+	}
+	drsi, err := st.DepositRequestsStartIndex()
+	if err != nil {
+		return nil, err
+	}
+	dbtc, err := st.DepositBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	ebtc, err := st.ExitBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	eee, err := st.EarliestExitEpoch()
+	if err != nil {
+		return nil, err
+	}
+	cbtc, err := st.ConsolidationBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	ece, err := st.EarliestConsolidationEpoch()
+	if err != nil {
+		return nil, err
+	}
+	pbd, err := st.PendingDeposits()
+	if err != nil {
+		return nil, err
+	}
+	ppw, err := st.PendingPartialWithdrawals()
+	if err != nil {
+		return nil, err
+	}
+	pc, err := st.PendingConsolidations()
+	if err != nil {
+		return nil, err
+	}
+	srcLookahead, err := st.ProposerLookahead()
+	if err != nil {
+		return nil, err
+	}
+	lookahead := make([]string, len(srcLookahead))
+	for i, v := range srcLookahead {
+		lookahead[i] = fmt.Sprintf("%d", uint64(v))
+	}
+	// Gloas-specific fields
+	lepb, err := st.LatestExecutionPayloadBid()
+	if err != nil {
+		return nil, err
+	}
+	builders, err := st.Builders()
+	if err != nil {
+		return nil, err
+	}
+	nwbi, err := st.NextWithdrawalBuilderIndex()
+	if err != nil {
+		return nil, err
+	}
+	epa, err := st.ExecutionPayloadAvailability()
+	if err != nil {
+		return nil, err
+	}
+	bpp, err := st.BuilderPendingPayments()
+	if err != nil {
+		return nil, err
+	}
+	bpw, err := st.BuilderPendingWithdrawals()
+	if err != nil {
+		return nil, err
+	}
+	lbh, err := st.LatestBlockHash()
+	if err != nil {
+		return nil, err
+	}
+	pew, err := st.PayloadExpectedWithdrawals()
+	if err != nil {
+		return nil, err
+	}
+
+	return &BeaconStateGloas{
+		GenesisTime:                   fmt.Sprintf("%d", st.GenesisTime().Unix()),
+		GenesisValidatorsRoot:         hexutil.Encode(st.GenesisValidatorsRoot()),
+		Slot:                          fmt.Sprintf("%d", st.Slot()),
+		Fork:                          ForkFromConsensus(st.Fork()),
+		LatestBlockHeader:             BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
+		BlockRoots:                    br,
+		StateRoots:                    sr,
+		HistoricalRoots:               hr,
+		Eth1Data:                      Eth1DataFromConsensus(st.Eth1Data()),
+		Eth1DataVotes:                 votes,
+		Eth1DepositIndex:              fmt.Sprintf("%d", st.Eth1DepositIndex()),
+		Validators:                    vals,
+		Balances:                      bals,
+		RandaoMixes:                   rm,
+		Slashings:                     slashings,
+		PreviousEpochParticipation:    prevPart,
+		CurrentEpochParticipation:     currPart,
+		JustificationBits:             hexutil.Encode(st.JustificationBits()),
+		PreviousJustifiedCheckpoint:   CheckpointFromConsensus(st.PreviousJustifiedCheckpoint()),
+		CurrentJustifiedCheckpoint:    CheckpointFromConsensus(st.CurrentJustifiedCheckpoint()),
+		FinalizedCheckpoint:           CheckpointFromConsensus(st.FinalizedCheckpoint()),
+		InactivityScores:              is,
+		CurrentSyncCommittee:          SyncCommitteeFromConsensus(currSc),
+		NextSyncCommittee:             SyncCommitteeFromConsensus(nextSc),
+		NextWithdrawalIndex:           fmt.Sprintf("%d", nwi),
+		NextWithdrawalValidatorIndex:  fmt.Sprintf("%d", nwvi),
+		HistoricalSummaries:           hs,
+		DepositRequestsStartIndex:     fmt.Sprintf("%d", drsi),
+		DepositBalanceToConsume:       fmt.Sprintf("%d", dbtc),
+		ExitBalanceToConsume:          fmt.Sprintf("%d", ebtc),
+		EarliestExitEpoch:             fmt.Sprintf("%d", eee),
+		ConsolidationBalanceToConsume: fmt.Sprintf("%d", cbtc),
+		EarliestConsolidationEpoch:    fmt.Sprintf("%d", ece),
+		PendingDeposits:               PendingDepositsFromConsensus(pbd),
+		PendingPartialWithdrawals:     PendingPartialWithdrawalsFromConsensus(ppw),
+		PendingConsolidations:         PendingConsolidationsFromConsensus(pc),
+		ProposerLookahead:             lookahead,
+		LatestExecutionPayloadBid:     ROExecutionPayloadBidFromConsensus(lepb),
+		Builders:                      BuildersFromConsensus(builders),
+		NextWithdrawalBuilderIndex:    fmt.Sprintf("%d", nwbi),
+		ExecutionPayloadAvailability:  hexutil.Encode(epa),
+		BuilderPendingPayments:        BuilderPendingPaymentsFromConsensus(bpp),
+		BuilderPendingWithdrawals:     BuilderPendingWithdrawalsFromConsensus(bpw),
+		LatestBlockHash:               hexutil.Encode(lbh[:]),
+		PayloadExpectedWithdrawals:    WithdrawalsFromConsensus(pew),
+	}, nil
+}

api/server/structs/conversions_test.go

@@ -1,11 +1,15 @@
 package structs
 
 import (
+	"bytes"
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/testing/assert"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
@@ -346,6 +350,176 @@ func TestAttesterSlashing_FromConsensus(t *testing.T) {
 	assert.DeepEqual(t, expectedResult, result)
 }
 
+func TestROExecutionPayloadBidFromConsensus(t *testing.T) {
+	bid := &eth.ExecutionPayloadBid{
+		ParentBlockHash:        bytes.Repeat([]byte{0x01}, 32),
+		ParentBlockRoot:        bytes.Repeat([]byte{0x02}, 32),
+		BlockHash:              bytes.Repeat([]byte{0x03}, 32),
+		PrevRandao:             bytes.Repeat([]byte{0x04}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0x05}, 20),
+		GasLimit:               100,
+		BuilderIndex:           7,
+		Slot:                   9,
+		Value:                  11,
+		ExecutionPayment:       22,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x06}, 32),
+	}
+	roBid, err := blocks.WrappedROExecutionPayloadBid(bid)
+	require.NoError(t, err)
+
+	got := ROExecutionPayloadBidFromConsensus(roBid)
+	want := &ExecutionPayloadBid{
+		ParentBlockHash:        hexutil.Encode(bid.ParentBlockHash),
+		ParentBlockRoot:        hexutil.Encode(bid.ParentBlockRoot),
+		BlockHash:              hexutil.Encode(bid.BlockHash),
+		PrevRandao:             hexutil.Encode(bid.PrevRandao),
+		FeeRecipient:           hexutil.Encode(bid.FeeRecipient),
+		GasLimit:               "100",
+		BuilderIndex:           "7",
+		Slot:                   "9",
+		Value:                  "11",
+		ExecutionPayment:       "22",
+		BlobKzgCommitmentsRoot: hexutil.Encode(bid.BlobKzgCommitmentsRoot),
+	}
+	assert.DeepEqual(t, want, got)
+}
+
+func TestBuilderConversionsFromConsensus(t *testing.T) {
+	builder := &eth.Builder{
+		Pubkey:            bytes.Repeat([]byte{0xAA}, 48),
+		Version:           bytes.Repeat([]byte{0x01}, 4),
+		ExecutionAddress:  bytes.Repeat([]byte{0xBB}, 20),
+		Balance:           42,
+		DepositEpoch:      3,
+		WithdrawableEpoch: 4,
+	}
+	wantBuilder := &Builder{
+		Pubkey:            hexutil.Encode(builder.Pubkey),
+		Version:           hexutil.Encode(builder.Version),
+		ExecutionAddress:  hexutil.Encode(builder.ExecutionAddress),
+		Balance:           "42",
+		DepositEpoch:      "3",
+		WithdrawableEpoch: "4",
+	}
+
+	assert.DeepEqual(t, wantBuilder, BuilderFromConsensus(builder))
+	assert.DeepEqual(t, []*Builder{wantBuilder}, BuildersFromConsensus([]*eth.Builder{builder}))
+}
+
+func TestBuilderPendingPaymentConversionsFromConsensus(t *testing.T) {
+	withdrawal := &eth.BuilderPendingWithdrawal{
+		FeeRecipient: bytes.Repeat([]byte{0x10}, 20),
+		Amount:       15,
+		BuilderIndex: 2,
+	}
+	payment := &eth.BuilderPendingPayment{
+		Weight:     5,
+		Withdrawal: withdrawal,
+	}
+	wantWithdrawal := &BuilderPendingWithdrawal{
+		FeeRecipient: hexutil.Encode(withdrawal.FeeRecipient),
+		Amount:       "15",
+		BuilderIndex: "2",
+	}
+	wantPayment := &BuilderPendingPayment{
+		Weight:     "5",
+		Withdrawal: wantWithdrawal,
+	}
+
+	assert.DeepEqual(t, wantPayment, BuilderPendingPaymentFromConsensus(payment))
+	assert.DeepEqual(t, []*BuilderPendingPayment{wantPayment}, BuilderPendingPaymentsFromConsensus([]*eth.BuilderPendingPayment{payment}))
+	assert.DeepEqual(t, wantWithdrawal, BuilderPendingWithdrawalFromConsensus(withdrawal))
+	assert.DeepEqual(t, []*BuilderPendingWithdrawal{wantWithdrawal}, BuilderPendingWithdrawalsFromConsensus([]*eth.BuilderPendingWithdrawal{withdrawal}))
+}
+
+func TestBeaconStateGloasFromConsensus(t *testing.T) {
+	st, err := util.NewBeaconStateGloas(func(state *eth.BeaconStateGloas) error {
+		state.GenesisTime = 123
+		state.GenesisValidatorsRoot = bytes.Repeat([]byte{0x10}, 32)
+		state.Slot = 5
+		state.ProposerLookahead = []uint64{1, 2}
+		state.LatestExecutionPayloadBid = &eth.ExecutionPayloadBid{
+			ParentBlockHash:        bytes.Repeat([]byte{0x11}, 32),
+			ParentBlockRoot:        bytes.Repeat([]byte{0x12}, 32),
+			BlockHash:              bytes.Repeat([]byte{0x13}, 32),
+			PrevRandao:             bytes.Repeat([]byte{0x14}, 32),
+			FeeRecipient:           bytes.Repeat([]byte{0x15}, 20),
+			GasLimit:               64,
+			BuilderIndex:           3,
+			Slot:                   5,
+			Value:                  99,
+			ExecutionPayment:       7,
+			BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x16}, 32),
+		}
+		state.Builders = []*eth.Builder{
+			{
+				Pubkey:            bytes.Repeat([]byte{0x20}, 48),
+				Version:           bytes.Repeat([]byte{0x21}, 4),
+				ExecutionAddress:  bytes.Repeat([]byte{0x22}, 20),
+				Balance:           88,
+				DepositEpoch:      1,
+				WithdrawableEpoch: 2,
+			},
+		}
+		state.NextWithdrawalBuilderIndex = 9
+		state.ExecutionPayloadAvailability = []byte{0x01, 0x02}
+		state.BuilderPendingPayments = []*eth.BuilderPendingPayment{
+			{
+				Weight: 3,
+				Withdrawal: &eth.BuilderPendingWithdrawal{
+					FeeRecipient: bytes.Repeat([]byte{0x23}, 20),
+					Amount:       4,
+					BuilderIndex: 5,
+				},
+			},
+		}
+		state.BuilderPendingWithdrawals = []*eth.BuilderPendingWithdrawal{
+			{
+				FeeRecipient: bytes.Repeat([]byte{0x24}, 20),
+				Amount:       6,
+				BuilderIndex: 7,
+			},
+		}
+		state.LatestBlockHash = bytes.Repeat([]byte{0x25}, 32)
+		state.PayloadExpectedWithdrawals = []*enginev1.Withdrawal{
+			{Index: 1, ValidatorIndex: 2, Address: bytes.Repeat([]byte{0x26}, 20), Amount: 10},
+		}
+		return nil
+	})
+	require.NoError(t, err)
+
+	got, err := BeaconStateGloasFromConsensus(st)
+	require.NoError(t, err)
+
+	require.Equal(t, "123", got.GenesisTime)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x10}, 32)), got.GenesisValidatorsRoot)
+	require.Equal(t, "5", got.Slot)
+	require.DeepEqual(t, []string{"1", "2"}, got.ProposerLookahead)
+	require.Equal(t, "9", got.NextWithdrawalBuilderIndex)
+	require.Equal(t, hexutil.Encode([]byte{0x01, 0x02}), got.ExecutionPayloadAvailability)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x25}, 32)), got.LatestBlockHash)
+
+	require.NotNil(t, got.LatestExecutionPayloadBid)
+	require.Equal(t, "64", got.LatestExecutionPayloadBid.GasLimit)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x11}, 32)), got.LatestExecutionPayloadBid.ParentBlockHash)
+
+	require.NotNil(t, got.Builders)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x20}, 48)), got.Builders[0].Pubkey)
+	require.Equal(t, "88", got.Builders[0].Balance)
+
+	require.Equal(t, "3", got.BuilderPendingPayments[0].Weight)
+	require.Equal(t, "4", got.BuilderPendingPayments[0].Withdrawal.Amount)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x23}, 20)), got.BuilderPendingPayments[0].Withdrawal.FeeRecipient)
+
+	require.Equal(t, "6", got.BuilderPendingWithdrawals[0].Amount)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x24}, 20)), got.BuilderPendingWithdrawals[0].FeeRecipient)
+
+	require.Equal(t, "1", got.PayloadExpectedWithdrawals[0].WithdrawalIndex)
+	require.Equal(t, "2", got.PayloadExpectedWithdrawals[0].ValidatorIndex)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x26}, 20)), got.PayloadExpectedWithdrawals[0].ExecutionAddress)
+	require.Equal(t, "10", got.PayloadExpectedWithdrawals[0].Amount)
+}
+
 func TestIndexedAttestation_ToConsensus(t *testing.T) {
 	a := &IndexedAttestation{
 		AttestingIndices: []string{"1"},

api/server/structs/other.go

@@ -262,3 +262,23 @@ type PendingConsolidation struct {
 	SourceIndex string `json:"source_index"`
 	TargetIndex string `json:"target_index"`
 }
+
+type Builder struct {
+	Pubkey            string `json:"pubkey"`
+	Version           string `json:"version"`
+	ExecutionAddress  string `json:"execution_address"`
+	Balance           string `json:"balance"`
+	DepositEpoch      string `json:"deposit_epoch"`
+	WithdrawableEpoch string `json:"withdrawable_epoch"`
+}
+
+type BuilderPendingPayment struct {
+	Weight     string                    `json:"weight"`
+	Withdrawal *BuilderPendingWithdrawal `json:"withdrawal"`
+}
+
+type BuilderPendingWithdrawal struct {
+	FeeRecipient string `json:"fee_recipient"`
+	Amount       string `json:"amount"`
+	BuilderIndex string `json:"builder_index"`
+}

api/server/structs/state.go

@@ -221,3 +221,51 @@ type BeaconStateFulu struct {
 	PendingConsolidations         []*PendingConsolidation      `json:"pending_consolidations"`
 	ProposerLookahead             []string                     `json:"proposer_lookahead"`
 }
+
+type BeaconStateGloas struct {
+	GenesisTime                   string                      `json:"genesis_time"`
+	GenesisValidatorsRoot         string                      `json:"genesis_validators_root"`
+	Slot                          string                      `json:"slot"`
+	Fork                          *Fork                       `json:"fork"`
+	LatestBlockHeader             *BeaconBlockHeader          `json:"latest_block_header"`
+	BlockRoots                    []string                    `json:"block_roots"`
+	StateRoots                    []string                    `json:"state_roots"`
+	HistoricalRoots               []string                    `json:"historical_roots"`
+	Eth1Data                      *Eth1Data                   `json:"eth1_data"`
+	Eth1DataVotes                 []*Eth1Data                 `json:"eth1_data_votes"`
+	Eth1DepositIndex              string                      `json:"eth1_deposit_index"`
+	Validators                    []*Validator                `json:"validators"`
+	Balances                      []string                    `json:"balances"`
+	RandaoMixes                   []string                    `json:"randao_mixes"`
+	Slashings                     []string                    `json:"slashings"`
+	PreviousEpochParticipation    []string                    `json:"previous_epoch_participation"`
+	CurrentEpochParticipation     []string                    `json:"current_epoch_participation"`
+	JustificationBits             string                      `json:"justification_bits"`
+	PreviousJustifiedCheckpoint   *Checkpoint                 `json:"previous_justified_checkpoint"`
+	CurrentJustifiedCheckpoint    *Checkpoint                 `json:"current_justified_checkpoint"`
+	FinalizedCheckpoint           *Checkpoint                 `json:"finalized_checkpoint"`
+	InactivityScores              []string                    `json:"inactivity_scores"`
+	CurrentSyncCommittee          *SyncCommittee              `json:"current_sync_committee"`
+	NextSyncCommittee             *SyncCommittee              `json:"next_sync_committee"`
+	NextWithdrawalIndex           string                      `json:"next_withdrawal_index"`
+	NextWithdrawalValidatorIndex  string                      `json:"next_withdrawal_validator_index"`
+	HistoricalSummaries           []*HistoricalSummary        `json:"historical_summaries"`
+	DepositRequestsStartIndex     string                      `json:"deposit_requests_start_index"`
+	DepositBalanceToConsume       string                      `json:"deposit_balance_to_consume"`
+	ExitBalanceToConsume          string                      `json:"exit_balance_to_consume"`
+	EarliestExitEpoch             string                      `json:"earliest_exit_epoch"`
+	ConsolidationBalanceToConsume string                      `json:"consolidation_balance_to_consume"`
+	EarliestConsolidationEpoch    string                      `json:"earliest_consolidation_epoch"`
+	PendingDeposits               []*PendingDeposit           `json:"pending_deposits"`
+	PendingPartialWithdrawals     []*PendingPartialWithdrawal `json:"pending_partial_withdrawals"`
+	PendingConsolidations         []*PendingConsolidation     `json:"pending_consolidations"`
+	ProposerLookahead             []string                    `json:"proposer_lookahead"`
+	LatestExecutionPayloadBid     *ExecutionPayloadBid        `json:"latest_execution_payload_bid"`
+	Builders                      []*Builder                  `json:"builders"`
+	NextWithdrawalBuilderIndex    string                      `json:"next_withdrawal_builder_index"`
+	ExecutionPayloadAvailability  string                      `json:"execution_payload_availability"`
+	BuilderPendingPayments        []*BuilderPendingPayment    `json:"builder_pending_payments"`
+	BuilderPendingWithdrawals     []*BuilderPendingWithdrawal `json:"builder_pending_withdrawals"`
+	LatestBlockHash               string                      `json:"latest_block_hash"`
+	PayloadExpectedWithdrawals    []*Withdrawal               `json:"payload_expected_withdrawals"`
+}

beacon-chain/core/gloas/BUILD.bazel

@@ -4,6 +4,9 @@ go_library(
     name = "go_default_library",
     srcs = [
         "bid.go",
+        "deposit_request.go",
+        "log.go",
+        "payload.go",
         "payload_attestation.go",
         "pending_payment.go",
         "proposer_slashing.go",
@@ -12,6 +15,7 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/requests:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",
@@ -25,9 +29,13 @@ go_library(
         "//crypto/bls/common:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//encoding/ssz:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )
 
@@ -35,7 +43,9 @@ go_test(
     name = "go_default_test",
     srcs = [
         "bid_test.go",
+        "deposit_request_test.go",
         "payload_attestation_test.go",
+        "payload_test.go",
         "pending_payment_test.go",
         "proposer_slashing_test.go",
     ],
@@ -45,6 +55,7 @@ go_test(
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
+        "//beacon-chain/state/testing:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
@@ -52,6 +63,7 @@ go_test(
         "//crypto/bls:go_default_library",
         "//crypto/bls/common:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//encoding/ssz:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/validator-client:go_default_library",

beacon-chain/core/gloas/deposit_request.go

@@ -0,0 +1,160 @@
+package gloas
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"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/encoding/bytesutil"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+)
+
+func processDepositRequests(ctx context.Context, beaconState state.BeaconState, requests []*enginev1.DepositRequest) error {
+	if len(requests) == 0 {
+		return nil
+	}
+
+	for _, receipt := range requests {
+		if err := processDepositRequest(beaconState, receipt); err != nil {
+			return errors.Wrap(err, "could not apply deposit request")
+		}
+	}
+	return nil
+}
+
+// processDepositRequest processes the specific deposit request
+// Spec v1.7.0-alpha.0 (pseudocode):
+// def process_deposit_request(state: BeaconState, deposit_request: DepositRequest) -> None:
+//
+//	# [New in Gloas:EIP7732]
+//	builder_pubkeys = [b.pubkey for b in state.builders]
+//	validator_pubkeys = [v.pubkey for v in state.validators]
+//
+//	# [New in Gloas:EIP7732]
+//	# Regardless of the withdrawal credentials prefix, if a builder/validator
+//	# already exists with this pubkey, apply the deposit to their balance
+//	is_builder = deposit_request.pubkey in builder_pubkeys
+//	is_validator = deposit_request.pubkey in validator_pubkeys
+//	is_builder_prefix = is_builder_withdrawal_credential(deposit_request.withdrawal_credentials)
+//	if is_builder or (is_builder_prefix and not is_validator):
+//
+//	    # Apply builder deposits immediately
+//	    apply_deposit_for_builder(
+//	        state,
+//	        deposit_request.pubkey,
+//	        deposit_request.withdrawal_credentials,
+//	        deposit_request.amount,
+//	        deposit_request.signature,
+//	    )
+//	    return
+//
+//	# Add validator deposits to the queue
+//	state.pending_deposits.append(
+//	    PendingDeposit(
+//	        pubkey=deposit_request.pubkey,
+//	        withdrawal_credentials=deposit_request.withdrawal_credentials,
+//	        amount=deposit_request.amount,
+//	        signature=deposit_request.signature,
+//	        slot=state.slot,
+//	    )
+//	)
+func processDepositRequest(beaconState state.BeaconState, request *enginev1.DepositRequest) error {
+	if request == nil {
+		return errors.New("nil deposit request")
+	}
+
+	if beaconState.Version() >= version.Gloas {
+		pubkey := bytesutil.ToBytes48(request.Pubkey)
+		_, isValidator := beaconState.ValidatorIndexByPubkey(pubkey)
+		_, isBuilder := beaconState.BuilderIndexByPubkey(pubkey)
+		isBuilderPrefix := IsBuilderWithdrawalCredential(request.WithdrawalCredentials)
+		if isBuilder || (isBuilderPrefix && !isValidator) {
+			if err := ApplyDepositForBuilder(
+				beaconState,
+				request.Pubkey,
+				request.WithdrawalCredentials,
+				request.Amount,
+				request.Signature,
+			); err != nil {
+				return errors.Wrap(err, "could not apply builder deposit")
+			}
+			return nil
+		}
+	}
+
+	if err := beaconState.AppendPendingDeposit(&ethpb.PendingDeposit{
+		PublicKey:             request.Pubkey,
+		WithdrawalCredentials: request.WithdrawalCredentials,
+		Amount:                request.Amount,
+		Signature:             request.Signature,
+		Slot:                  beaconState.Slot(),
+	}); err != nil {
+		return errors.Wrap(err, "could not append deposit request")
+	}
+	return nil
+}
+
+// ApplyDepositForBuilder processes an execution-layer deposit for a builder.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// def apply_deposit_for_builder(
+//
+//	state: BeaconState,
+//	pubkey: BLSPubkey,
+//	withdrawal_credentials: Bytes32,
+//	amount: uint64,
+//	signature: BLSSignature,
+//
+// ) -> None:
+//
+//	builder_pubkeys = [b.pubkey for b in state.builders]
+//	if pubkey not in builder_pubkeys:
+//	    # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
+//	    if is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature):
+//	        add_builder_to_registry(state, pubkey, withdrawal_credentials, amount)
+//	else:
+//	    # Increase balance by deposit amount
+//	    builder_index = builder_pubkeys.index(pubkey)
+//	    state.builders[builder_index].balance += amount
+func ApplyDepositForBuilder(
+	beaconState state.BeaconState,
+	pubkey []byte,
+	withdrawalCredentials []byte,
+	amount uint64,
+	signature []byte,
+) error {
+	pubkeyBytes := bytesutil.ToBytes48(pubkey)
+	if idx, exists := beaconState.BuilderIndexByPubkey(pubkeyBytes); exists {
+		return beaconState.IncreaseBuilderBalance(idx, amount)
+	}
+
+	valid, err := helpers.IsValidDepositSignature(&ethpb.Deposit_Data{
+		PublicKey:             pubkey,
+		WithdrawalCredentials: withdrawalCredentials,
+		Amount:                amount,
+		Signature:             signature,
+	})
+	if err != nil {
+		return errors.Wrap(err, "could not verify deposit signature")
+	}
+	if !valid {
+		log.WithFields(logrus.Fields{
+			"pubkey": fmt.Sprintf("%x", pubkey),
+		}).Warn("ignoring builder deposit: invalid signature")
+		return nil
+	}
+
+	withdrawalCredBytes := bytesutil.ToBytes32(withdrawalCredentials)
+	return beaconState.AddBuilderFromDeposit(pubkeyBytes, withdrawalCredBytes, amount)
+}
+
+func IsBuilderWithdrawalCredential(withdrawalCredentials []byte) bool {
+	return len(withdrawalCredentials) == fieldparams.RootLength &&
+		withdrawalCredentials[0] == params.BeaconConfig().BuilderWithdrawalPrefixByte
+}

beacon-chain/core/gloas/deposit_request_test.go

@@ -0,0 +1,150 @@
+package gloas
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	stateTesting "github.com/OffchainLabs/prysm/v7/beacon-chain/state/testing"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls"
+	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"
+)
+
+func TestProcessDepositRequests_EmptyAndNil(t *testing.T) {
+	st := newGloasState(t, nil, nil)
+
+	t.Run("empty requests continues", func(t *testing.T) {
+		err := processDepositRequests(t.Context(), st, []*enginev1.DepositRequest{})
+		require.NoError(t, err)
+	})
+
+	t.Run("nil request errors", func(t *testing.T) {
+		err := processDepositRequests(t.Context(), st, []*enginev1.DepositRequest{nil})
+		require.ErrorContains(t, "nil deposit request", err)
+	})
+}
+
+func TestProcessDepositRequest_BuilderDepositAddsBuilder(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+
+	cred := builderWithdrawalCredentials()
+	pd := stateTesting.GeneratePendingDeposit(t, sk, 1234, cred, 0)
+	req := depositRequestFromPending(pd, 1)
+
+	st := newGloasState(t, nil, nil)
+	err = processDepositRequest(st, req)
+	require.NoError(t, err)
+
+	idx, ok := st.BuilderIndexByPubkey(toBytes48(req.Pubkey))
+	require.Equal(t, true, ok)
+
+	builder, err := st.Builder(idx)
+	require.NoError(t, err)
+	require.NotNil(t, builder)
+	require.DeepEqual(t, req.Pubkey, builder.Pubkey)
+	require.DeepEqual(t, []byte{cred[0]}, builder.Version)
+	require.DeepEqual(t, cred[12:], builder.ExecutionAddress)
+	require.Equal(t, uint64(1234), uint64(builder.Balance))
+	require.Equal(t, params.BeaconConfig().FarFutureEpoch, builder.WithdrawableEpoch)
+
+	pending, err := st.PendingDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 0, len(pending))
+}
+
+func TestProcessDepositRequest_ExistingBuilderIncreasesBalance(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+
+	pubkey := sk.PublicKey().Marshal()
+	builders := []*ethpb.Builder{
+		{
+			Pubkey:            pubkey,
+			Version:           []byte{0},
+			ExecutionAddress:  bytes.Repeat([]byte{0x11}, 20),
+			Balance:           5,
+			WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
+		},
+	}
+	st := newGloasState(t, nil, builders)
+
+	cred := validatorWithdrawalCredentials()
+	pd := stateTesting.GeneratePendingDeposit(t, sk, 200, cred, 0)
+	req := depositRequestFromPending(pd, 9)
+
+	err = processDepositRequest(st, req)
+	require.NoError(t, err)
+
+	idx, ok := st.BuilderIndexByPubkey(toBytes48(pubkey))
+	require.Equal(t, true, ok)
+	builder, err := st.Builder(idx)
+	require.NoError(t, err)
+	require.Equal(t, uint64(205), uint64(builder.Balance))
+
+	pending, err := st.PendingDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 0, len(pending))
+}
+
+func TestApplyDepositForBuilder_InvalidSignatureIgnoresDeposit(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+
+	cred := builderWithdrawalCredentials()
+	st := newGloasState(t, nil, nil)
+	err = ApplyDepositForBuilder(st, sk.PublicKey().Marshal(), cred[:], 100, make([]byte, 96))
+	require.NoError(t, err)
+
+	_, ok := st.BuilderIndexByPubkey(toBytes48(sk.PublicKey().Marshal()))
+	require.Equal(t, false, ok)
+}
+
+func newGloasState(t *testing.T, validators []*ethpb.Validator, builders []*ethpb.Builder) state.BeaconState {
+	t.Helper()
+
+	st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+		DepositRequestsStartIndex: params.BeaconConfig().UnsetDepositRequestsStartIndex,
+		Validators:                validators,
+		Balances:                  make([]uint64, len(validators)),
+		PendingDeposits:           []*ethpb.PendingDeposit{},
+		Builders:                  builders,
+	})
+	require.NoError(t, err)
+
+	return st
+}
+
+func depositRequestFromPending(pd *ethpb.PendingDeposit, index uint64) *enginev1.DepositRequest {
+	return &enginev1.DepositRequest{
+		Pubkey:                pd.PublicKey,
+		WithdrawalCredentials: pd.WithdrawalCredentials,
+		Amount:                pd.Amount,
+		Signature:             pd.Signature,
+		Index:                 index,
+	}
+}
+
+func builderWithdrawalCredentials() [32]byte {
+	var cred [32]byte
+	cred[0] = params.BeaconConfig().BuilderWithdrawalPrefixByte
+	copy(cred[12:], bytes.Repeat([]byte{0x22}, 20))
+	return cred
+}
+
+func validatorWithdrawalCredentials() [32]byte {
+	var cred [32]byte
+	cred[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+	copy(cred[12:], bytes.Repeat([]byte{0x33}, 20))
+	return cred
+}
+
+func toBytes48(b []byte) [48]byte {
+	var out [48]byte
+	copy(out[:], b)
+	return out
+}

beacon-chain/core/gloas/log.go

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

beacon-chain/core/gloas/payload.go

@@ -0,0 +1,330 @@
+package gloas
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	requests "github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls"
+	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+	"github.com/pkg/errors"
+)
+
+// ProcessExecutionPayload processes the signed execution payload envelope for the Gloas fork.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// def process_execution_payload(
+//
+//	state: BeaconState,
+//	signed_envelope: SignedExecutionPayloadEnvelope,
+//	execution_engine: ExecutionEngine,
+//	verify: bool = True,
+//
+// ) -> None:
+//
+//	envelope = signed_envelope.message
+//	payload = envelope.payload
+//
+//	if verify:
+//	    assert verify_execution_payload_envelope_signature(state, signed_envelope)
+//
+//	previous_state_root = hash_tree_root(state)
+//	if state.latest_block_header.state_root == Root():
+//	    state.latest_block_header.state_root = previous_state_root
+//
+//	assert envelope.beacon_block_root == hash_tree_root(state.latest_block_header)
+//	assert envelope.slot == state.slot
+//
+//	committed_bid = state.latest_execution_payload_bid
+//	assert envelope.builder_index == committed_bid.builder_index
+//	assert committed_bid.blob_kzg_commitments_root == hash_tree_root(envelope.blob_kzg_commitments)
+//	assert committed_bid.prev_randao == payload.prev_randao
+//
+//	assert hash_tree_root(payload.withdrawals) == hash_tree_root(state.payload_expected_withdrawals)
+//
+//	assert committed_bid.gas_limit == payload.gas_limit
+//	assert committed_bid.block_hash == payload.block_hash
+//	assert payload.parent_hash == state.latest_block_hash
+//	assert payload.timestamp == compute_time_at_slot(state, state.slot)
+//	assert (
+//	    len(envelope.blob_kzg_commitments)
+//	    <= get_blob_parameters(get_current_epoch(state)).max_blobs_per_block
+//	)
+//	versioned_hashes = [
+//	    kzg_commitment_to_versioned_hash(commitment) for commitment in envelope.blob_kzg_commitments
+//	]
+//	requests = envelope.execution_requests
+//	assert execution_engine.verify_and_notify_new_payload(
+//	    NewPayloadRequest(
+//	        execution_payload=payload,
+//	        versioned_hashes=versioned_hashes,
+//	        parent_beacon_block_root=state.latest_block_header.parent_root,
+//	        execution_requests=requests,
+//	    )
+//	)
+//
+//	for op in requests.deposits: process_deposit_request(state, op)
+//	for op in requests.withdrawals: process_withdrawal_request(state, op)
+//	for op in requests.consolidations: process_consolidation_request(state, op)
+//
+//	payment = state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH]
+//	amount = payment.withdrawal.amount
+//	if amount > 0:
+//	    state.builder_pending_withdrawals.append(payment.withdrawal)
+//	state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH] = (
+//	    BuilderPendingPayment()
+//	)
+//
+//	state.execution_payload_availability[state.slot % SLOTS_PER_HISTORICAL_ROOT] = 0b1
+//	state.latest_block_hash = payload.block_hash
+//
+//	if verify:
+//	    assert envelope.state_root == hash_tree_root(state)
+func ProcessExecutionPayload(
+	ctx context.Context,
+	st state.BeaconState,
+	signedEnvelope interfaces.ROSignedExecutionPayloadEnvelope,
+) error {
+	if err := verifyExecutionPayloadEnvelopeSignature(st, signedEnvelope); err != nil {
+		return errors.Wrap(err, "signature verification failed")
+	}
+
+	latestHeader := st.LatestBlockHeader()
+	if len(latestHeader.StateRoot) == 0 || bytes.Equal(latestHeader.StateRoot, make([]byte, 32)) {
+		previousStateRoot, err := st.HashTreeRoot(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not compute state root")
+		}
+		latestHeader.StateRoot = previousStateRoot[:]
+		if err := st.SetLatestBlockHeader(latestHeader); err != nil {
+			return errors.Wrap(err, "could not set latest block header")
+		}
+	}
+
+	blockHeaderRoot, err := latestHeader.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not compute block header root")
+	}
+	envelope, err := signedEnvelope.Envelope()
+	if err != nil {
+		return errors.Wrap(err, "could not get envelope from signed envelope")
+	}
+	beaconBlockRoot := envelope.BeaconBlockRoot()
+	if !bytes.Equal(beaconBlockRoot[:], blockHeaderRoot[:]) {
+		return errors.Errorf("envelope beacon block root does not match state latest block header root: envelope=%#x, header=%#x", beaconBlockRoot, blockHeaderRoot)
+	}
+
+	if envelope.Slot() != st.Slot() {
+		return errors.Errorf("envelope slot does not match state slot: envelope=%d, state=%d", envelope.Slot(), st.Slot())
+	}
+
+	latestBid, err := st.LatestExecutionPayloadBid()
+	if err != nil {
+		return errors.Wrap(err, "could not get latest execution payload bid")
+	}
+	if latestBid == nil {
+		return errors.New("latest execution payload bid is nil")
+	}
+	if envelope.BuilderIndex() != latestBid.BuilderIndex() {
+		return errors.Errorf("envelope builder index does not match committed bid builder index: envelope=%d, bid=%d", envelope.BuilderIndex(), latestBid.BuilderIndex())
+	}
+
+	envelopeBlobCommitments := envelope.BlobKzgCommitments()
+	envelopeBlobRoot, err := ssz.KzgCommitmentsRoot(envelopeBlobCommitments)
+	if err != nil {
+		return errors.Wrap(err, "could not compute envelope blob KZG commitments root")
+	}
+	committedBlobRoot := latestBid.BlobKzgCommitmentsRoot()
+	if !bytes.Equal(committedBlobRoot[:], envelopeBlobRoot[:]) {
+		return errors.Errorf("committed bid blob KZG commitments root does not match envelope: bid=%#x, envelope=%#x", committedBlobRoot, envelopeBlobRoot)
+	}
+
+	payload, err := envelope.Execution()
+	if err != nil {
+		return errors.Wrap(err, "could not get execution payload from envelope")
+	}
+	withdrawals, err := payload.Withdrawals()
+	if err != nil {
+		return errors.Wrap(err, "could not get withdrawals from payload")
+	}
+
+	ok, err := st.WithdrawalsMatchPayloadExpected(withdrawals)
+	if err != nil {
+		return errors.Wrap(err, "could not validate payload withdrawals")
+	}
+	if !ok {
+		return errors.New("payload withdrawals do not match expected withdrawals")
+	}
+
+	if latestBid.GasLimit() != payload.GasLimit() {
+		return errors.Errorf("committed bid gas limit does not match payload gas limit: bid=%d, payload=%d", latestBid.GasLimit(), payload.GasLimit())
+	}
+
+	latestBidPrevRandao := latestBid.PrevRandao()
+	if !bytes.Equal(payload.PrevRandao(), latestBidPrevRandao[:]) {
+		return errors.Errorf("payload prev randao does not match committed bid prev randao: payload=%#x, bid=%#x", payload.PrevRandao(), latestBidPrevRandao)
+	}
+
+	bidBlockHash := latestBid.BlockHash()
+	payloadBlockHash := payload.BlockHash()
+	if !bytes.Equal(bidBlockHash[:], payloadBlockHash) {
+		return errors.Errorf("committed bid block hash does not match payload block hash: bid=%#x, payload=%#x", bidBlockHash, payloadBlockHash)
+	}
+
+	latestBlockHash, err := st.LatestBlockHash()
+	if err != nil {
+		return errors.Wrap(err, "could not get latest block hash")
+	}
+	if !bytes.Equal(payload.ParentHash(), latestBlockHash[:]) {
+		return errors.Errorf("payload parent hash does not match state latest block hash: payload=%#x, state=%#x", payload.ParentHash(), latestBlockHash)
+	}
+
+	t, err := slots.StartTime(st.GenesisTime(), st.Slot())
+	if err != nil {
+		return errors.Wrap(err, "could not compute timestamp")
+	}
+	if payload.Timestamp() != uint64(t.Unix()) {
+		return errors.Errorf("payload timestamp does not match expected timestamp: payload=%d, expected=%d", payload.Timestamp(), uint64(t.Unix()))
+	}
+
+	cfg := params.BeaconConfig()
+	maxBlobsPerBlock := cfg.MaxBlobsPerBlock(envelope.Slot())
+	if len(envelopeBlobCommitments) > maxBlobsPerBlock {
+		return errors.Errorf("too many blob KZG commitments: got=%d, max=%d", len(envelopeBlobCommitments), maxBlobsPerBlock)
+	}
+
+	if err := processExecutionRequests(ctx, st, envelope.ExecutionRequests()); err != nil {
+		return errors.Wrap(err, "could not process execution requests")
+	}
+
+	if err := st.QueueBuilderPayment(); err != nil {
+		return errors.Wrap(err, "could not queue builder payment")
+	}
+
+	if err := st.SetExecutionPayloadAvailability(st.Slot(), true); err != nil {
+		return errors.Wrap(err, "could not set execution payload availability")
+	}
+
+	if err := st.SetLatestBlockHash([32]byte(payload.BlockHash())); err != nil {
+		return errors.Wrap(err, "could not set latest block hash")
+	}
+
+	r, err := st.HashTreeRoot(ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get hash tree root")
+	}
+	if r != envelope.StateRoot() {
+		return fmt.Errorf("state root mismatch: expected %#x, got %#x", envelope.StateRoot(), r)
+	}
+
+	return nil
+}
+
+// processExecutionRequests processes deposits, withdrawals, and consolidations from execution requests.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// for op in requests.deposits: process_deposit_request(state, op)
+// for op in requests.withdrawals: process_withdrawal_request(state, op)
+// for op in requests.consolidations: process_consolidation_request(state, op)
+func processExecutionRequests(ctx context.Context, st state.BeaconState, rqs *enginev1.ExecutionRequests) error {
+	if err := processDepositRequests(ctx, st, rqs.Deposits); err != nil {
+		return errors.Wrap(err, "could not process deposit requests")
+	}
+
+	var err error
+	st, err = requests.ProcessWithdrawalRequests(ctx, st, rqs.Withdrawals)
+	if err != nil {
+		return errors.Wrap(err, "could not process withdrawal requests")
+	}
+	err = requests.ProcessConsolidationRequests(ctx, st, rqs.Consolidations)
+	if err != nil {
+		return errors.Wrap(err, "could not process consolidation requests")
+	}
+	return nil
+}
+
+// verifyExecutionPayloadEnvelopeSignature verifies the BLS signature on a signed execution payload envelope.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// builder_index = signed_envelope.message.builder_index
+// if builder_index == BUILDER_INDEX_SELF_BUILD:
+//
+//	validator_index = state.latest_block_header.proposer_index
+//	pubkey = state.validators[validator_index].pubkey
+//
+// else:
+//
+//	pubkey = state.builders[builder_index].pubkey
+//
+// signing_root = compute_signing_root(
+//
+//	signed_envelope.message, get_domain(state, DOMAIN_BEACON_BUILDER)
+//
+// )
+// return bls.Verify(pubkey, signing_root, signed_envelope.signature)
+func verifyExecutionPayloadEnvelopeSignature(st state.BeaconState, signedEnvelope interfaces.ROSignedExecutionPayloadEnvelope) error {
+	envelope, err := signedEnvelope.Envelope()
+	if err != nil {
+		return fmt.Errorf("failed to get envelope: %w", err)
+	}
+
+	builderIdx := envelope.BuilderIndex()
+	var publicKey bls.PublicKey
+	if builderIdx == params.BeaconConfig().BuilderIndexSelfBuild {
+		header := st.LatestBlockHeader()
+		if header == nil {
+			return fmt.Errorf("latest block header is nil")
+		}
+		proposerPubkey := st.PubkeyAtIndex(header.ProposerIndex)
+		key, err := bls.PublicKeyFromBytes(proposerPubkey[:])
+		if err != nil {
+			return fmt.Errorf("invalid proposer public key: %w", err)
+		}
+		publicKey = key
+	} else {
+		builder, err := st.Builder(builderIdx)
+		if err != nil {
+			return fmt.Errorf("failed to get builder: %w", err)
+		}
+		if builder == nil {
+			return fmt.Errorf("builder at index %d not found", builderIdx)
+		}
+		key, err := bls.PublicKeyFromBytes(builder.Pubkey)
+		if err != nil {
+			return fmt.Errorf("invalid builder public key: %w", err)
+		}
+		publicKey = key
+	}
+
+	signatureBytes := signedEnvelope.Signature()
+	signature, err := bls.SignatureFromBytes(signatureBytes[:])
+	if err != nil {
+		return fmt.Errorf("invalid signature format: %w", err)
+	}
+
+	currentEpoch := slots.ToEpoch(envelope.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 := signedEnvelope.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/payload_test.go

@@ -0,0 +1,360 @@
+package gloas
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls"
+	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
+	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/OffchainLabs/prysm/v7/time/slots"
+	"google.golang.org/protobuf/proto"
+)
+
+type payloadFixture struct {
+	state       state.BeaconState
+	signed      interfaces.ROSignedExecutionPayloadEnvelope
+	signedProto *ethpb.SignedExecutionPayloadEnvelope
+	envelope    *ethpb.ExecutionPayloadEnvelope
+	payload     *enginev1.ExecutionPayloadDeneb
+	slot        primitives.Slot
+}
+
+func buildPayloadFixture(t *testing.T, mutate func(payload *enginev1.ExecutionPayloadDeneb, bid *ethpb.ExecutionPayloadBid, envelope *ethpb.ExecutionPayloadEnvelope)) payloadFixture {
+	t.Helper()
+
+	cfg := params.BeaconConfig()
+	slot := primitives.Slot(5)
+	builderIdx := primitives.BuilderIndex(0)
+
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	pk := sk.PublicKey().Marshal()
+
+	randao := bytes.Repeat([]byte{0xAA}, 32)
+	parentHash := bytes.Repeat([]byte{0xBB}, 32)
+	blockHash := bytes.Repeat([]byte{0xCC}, 32)
+
+	withdrawals := []*enginev1.Withdrawal{
+		{Index: 0, ValidatorIndex: 1, Address: bytes.Repeat([]byte{0x01}, 20), Amount: 0},
+	}
+
+	blobCommitments := [][]byte{}
+	blobRoot, err := ssz.KzgCommitmentsRoot(blobCommitments)
+	require.NoError(t, err)
+
+	payload := &enginev1.ExecutionPayloadDeneb{
+		ParentHash:    parentHash,
+		FeeRecipient:  bytes.Repeat([]byte{0x01}, 20),
+		StateRoot:     bytes.Repeat([]byte{0x02}, 32),
+		ReceiptsRoot:  bytes.Repeat([]byte{0x03}, 32),
+		LogsBloom:     bytes.Repeat([]byte{0x04}, 256),
+		PrevRandao:    randao,
+		BlockNumber:   1,
+		GasLimit:      1,
+		GasUsed:       0,
+		Timestamp:     100,
+		ExtraData:     []byte{},
+		BaseFeePerGas: bytes.Repeat([]byte{0x05}, 32),
+		BlockHash:     blockHash,
+		Transactions:  [][]byte{},
+		Withdrawals:   withdrawals,
+		BlobGasUsed:   0,
+		ExcessBlobGas: 0,
+	}
+
+	bid := &ethpb.ExecutionPayloadBid{
+		ParentBlockHash:        parentHash,
+		ParentBlockRoot:        bytes.Repeat([]byte{0xDD}, 32),
+		BlockHash:              blockHash,
+		PrevRandao:             randao,
+		GasLimit:               1,
+		BuilderIndex:           builderIdx,
+		Slot:                   slot,
+		Value:                  0,
+		ExecutionPayment:       0,
+		BlobKzgCommitmentsRoot: blobRoot[:],
+		FeeRecipient:           bytes.Repeat([]byte{0xEE}, 20),
+	}
+
+	header := &ethpb.BeaconBlockHeader{
+		Slot:       slot,
+		ParentRoot: bytes.Repeat([]byte{0x11}, 32),
+		StateRoot:  bytes.Repeat([]byte{0x22}, 32),
+		BodyRoot:   bytes.Repeat([]byte{0x33}, 32),
+	}
+	headerRoot, err := header.HashTreeRoot()
+	require.NoError(t, err)
+
+	envelope := &ethpb.ExecutionPayloadEnvelope{
+		Slot:               slot,
+		BuilderIndex:       builderIdx,
+		BeaconBlockRoot:    headerRoot[:],
+		Payload:            payload,
+		BlobKzgCommitments: blobCommitments,
+		ExecutionRequests:  &enginev1.ExecutionRequests{},
+	}
+
+	if mutate != nil {
+		mutate(payload, bid, envelope)
+	}
+
+	genesisRoot := bytes.Repeat([]byte{0xAB}, 32)
+	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for i := range blockRoots {
+		blockRoots[i] = bytes.Repeat([]byte{0x44}, 32)
+		stateRoots[i] = bytes.Repeat([]byte{0x55}, 32)
+	}
+	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
+	for i := range randaoMixes {
+		randaoMixes[i] = randao
+	}
+
+	withdrawalCreds := make([]byte, 32)
+	withdrawalCreds[0] = cfg.ETH1AddressWithdrawalPrefixByte
+
+	eth1Data := &ethpb.Eth1Data{
+		DepositRoot:  bytes.Repeat([]byte{0x66}, 32),
+		DepositCount: 0,
+		BlockHash:    bytes.Repeat([]byte{0x77}, 32),
+	}
+
+	vals := []*ethpb.Validator{
+		{
+			PublicKey:             pk,
+			WithdrawalCredentials: withdrawalCreds,
+			EffectiveBalance:      cfg.MinActivationBalance + 1_000,
+		},
+	}
+	balances := []uint64{cfg.MinActivationBalance + 1_000}
+
+	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
+	for i := range payments {
+		payments[i] = &ethpb.BuilderPendingPayment{
+			Withdrawal: &ethpb.BuilderPendingWithdrawal{
+				FeeRecipient: make([]byte, 20),
+			},
+		}
+	}
+
+	executionPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
+
+	builders := make([]*ethpb.Builder, builderIdx+1)
+	builders[builderIdx] = &ethpb.Builder{
+		Pubkey:            pk,
+		Version:           []byte{0},
+		ExecutionAddress:  bytes.Repeat([]byte{0x09}, 20),
+		Balance:           0,
+		DepositEpoch:      0,
+		WithdrawableEpoch: 0,
+	}
+
+	genesisTime := uint64(0)
+	slotSeconds := cfg.SecondsPerSlot * uint64(slot)
+	if payload.Timestamp > slotSeconds {
+		genesisTime = payload.Timestamp - slotSeconds
+	}
+
+	stProto := &ethpb.BeaconStateGloas{
+		Slot:                  slot,
+		GenesisTime:           genesisTime,
+		GenesisValidatorsRoot: genesisRoot,
+		Fork: &ethpb.Fork{
+			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
+			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
+			Epoch:           0,
+		},
+		LatestBlockHeader:            header,
+		BlockRoots:                   blockRoots,
+		StateRoots:                   stateRoots,
+		RandaoMixes:                  randaoMixes,
+		Eth1Data:                     eth1Data,
+		Validators:                   vals,
+		Balances:                     balances,
+		LatestBlockHash:              payload.ParentHash,
+		LatestExecutionPayloadBid:    bid,
+		BuilderPendingPayments:       payments,
+		ExecutionPayloadAvailability: executionPayloadAvailability,
+		BuilderPendingWithdrawals:    []*ethpb.BuilderPendingWithdrawal{},
+		PayloadExpectedWithdrawals:   payload.Withdrawals,
+		Builders:                     builders,
+	}
+
+	st, err := state_native.InitializeFromProtoGloas(stProto)
+	require.NoError(t, err)
+
+	expected := st.Copy()
+	ctx := context.Background()
+	require.NoError(t, processExecutionRequests(ctx, expected, envelope.ExecutionRequests))
+	require.NoError(t, expected.QueueBuilderPayment())
+	require.NoError(t, expected.SetExecutionPayloadAvailability(slot, true))
+	var blockHashArr [32]byte
+	copy(blockHashArr[:], payload.BlockHash)
+	require.NoError(t, expected.SetLatestBlockHash(blockHashArr))
+	expectedRoot, err := expected.HashTreeRoot(ctx)
+	require.NoError(t, err)
+	envelope.StateRoot = expectedRoot[:]
+
+	epoch := slots.ToEpoch(slot)
+	domain, err := signing.Domain(st.Fork(), epoch, cfg.DomainBeaconBuilder, st.GenesisValidatorsRoot())
+	require.NoError(t, err)
+	signingRoot, err := signing.ComputeSigningRoot(envelope, domain)
+	require.NoError(t, err)
+	signature := sk.Sign(signingRoot[:]).Marshal()
+
+	signedProto := &ethpb.SignedExecutionPayloadEnvelope{
+		Message:   envelope,
+		Signature: signature,
+	}
+	signed, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
+	require.NoError(t, err)
+
+	return payloadFixture{
+		state:       st,
+		signed:      signed,
+		signedProto: signedProto,
+		envelope:    envelope,
+		payload:     payload,
+		slot:        slot,
+	}
+}
+
+func TestProcessExecutionPayload_Success(t *testing.T) {
+	fixture := buildPayloadFixture(t, nil)
+	require.NoError(t, ProcessExecutionPayload(t.Context(), fixture.state, fixture.signed))
+
+	latestHash, err := fixture.state.LatestBlockHash()
+	require.NoError(t, err)
+	var expectedHash [32]byte
+	copy(expectedHash[:], fixture.payload.BlockHash)
+	require.Equal(t, expectedHash, latestHash)
+
+	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+	paymentIndex := slotsPerEpoch + (fixture.slot % slotsPerEpoch)
+	payments, err := fixture.state.BuilderPendingPayments()
+	require.NoError(t, err)
+	payment := payments[paymentIndex]
+	require.NotNil(t, payment)
+	require.Equal(t, primitives.Gwei(0), payment.Withdrawal.Amount)
+}
+
+func TestProcessExecutionPayload_PrevRandaoMismatch(t *testing.T) {
+	fixture := buildPayloadFixture(t, func(_ *enginev1.ExecutionPayloadDeneb, bid *ethpb.ExecutionPayloadBid, _ *ethpb.ExecutionPayloadEnvelope) {
+		bid.PrevRandao = bytes.Repeat([]byte{0xFF}, 32)
+	})
+
+	err := ProcessExecutionPayload(t.Context(), fixture.state, fixture.signed)
+	require.ErrorContains(t, "prev randao", err)
+}
+
+func TestQueueBuilderPayment_ZeroAmountClearsSlot(t *testing.T) {
+	fixture := buildPayloadFixture(t, nil)
+
+	require.NoError(t, fixture.state.QueueBuilderPayment())
+
+	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+	paymentIndex := slotsPerEpoch + (fixture.slot % slotsPerEpoch)
+	payments, err := fixture.state.BuilderPendingPayments()
+	require.NoError(t, err)
+	payment := payments[paymentIndex]
+	require.NotNil(t, payment)
+	require.Equal(t, primitives.Gwei(0), payment.Withdrawal.Amount)
+}
+
+func TestVerifyExecutionPayloadEnvelopeSignature(t *testing.T) {
+	fixture := buildPayloadFixture(t, nil)
+
+	t.Run("self build", func(t *testing.T) {
+		proposerSk, err := bls.RandKey()
+		require.NoError(t, err)
+		proposerPk := proposerSk.PublicKey().Marshal()
+
+		stPb, ok := fixture.state.ToProtoUnsafe().(*ethpb.BeaconStateGloas)
+		require.Equal(t, true, ok)
+		stPb = proto.Clone(stPb).(*ethpb.BeaconStateGloas)
+		stPb.Validators[0].PublicKey = proposerPk
+		st, err := state_native.InitializeFromProtoUnsafeGloas(stPb)
+		require.NoError(t, err)
+
+		msg := proto.Clone(fixture.signedProto.Message).(*ethpb.ExecutionPayloadEnvelope)
+		msg.BuilderIndex = params.BeaconConfig().BuilderIndexSelfBuild
+		msg.BlobKzgCommitments = []([]byte){}
+
+		epoch := slots.ToEpoch(msg.Slot)
+		domain, err := signing.Domain(st.Fork(), epoch, params.BeaconConfig().DomainBeaconBuilder, st.GenesisValidatorsRoot())
+		require.NoError(t, err)
+		signingRoot, err := signing.ComputeSigningRoot(msg, domain)
+		require.NoError(t, err)
+		signature := proposerSk.Sign(signingRoot[:]).Marshal()
+
+		signedProto := &ethpb.SignedExecutionPayloadEnvelope{
+			Message:   msg,
+			Signature: signature,
+		}
+		signed, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
+		require.NoError(t, err)
+
+		require.NoError(t, verifyExecutionPayloadEnvelopeSignature(st, signed))
+	})
+
+	t.Run("builder", func(t *testing.T) {
+		signed, err := blocks.WrappedROSignedExecutionPayloadEnvelope(fixture.signedProto)
+		require.NoError(t, err)
+
+		require.NoError(t, verifyExecutionPayloadEnvelopeSignature(fixture.state, signed))
+	})
+
+	t.Run("invalid signature", func(t *testing.T) {
+		t.Run("self build", func(t *testing.T) {
+			proposerSk, err := bls.RandKey()
+			require.NoError(t, err)
+			proposerPk := proposerSk.PublicKey().Marshal()
+
+			stPb, ok := fixture.state.ToProtoUnsafe().(*ethpb.BeaconStateGloas)
+			require.Equal(t, true, ok)
+			stPb = proto.Clone(stPb).(*ethpb.BeaconStateGloas)
+			stPb.Validators[0].PublicKey = proposerPk
+			st, err := state_native.InitializeFromProtoUnsafeGloas(stPb)
+			require.NoError(t, err)
+
+			msg := proto.Clone(fixture.signedProto.Message).(*ethpb.ExecutionPayloadEnvelope)
+			msg.BuilderIndex = params.BeaconConfig().BuilderIndexSelfBuild
+			if msg.BlobKzgCommitments == nil {
+				msg.BlobKzgCommitments = [][]byte{}
+			}
+
+			signedProto := &ethpb.SignedExecutionPayloadEnvelope{
+				Message:   msg,
+				Signature: bytes.Repeat([]byte{0xFF}, 96),
+			}
+			badSigned, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
+			require.NoError(t, err)
+
+			err = verifyExecutionPayloadEnvelopeSignature(st, badSigned)
+			require.ErrorContains(t, "invalid signature format", err)
+		})
+
+		t.Run("builder", func(t *testing.T) {
+			signedProto := &ethpb.SignedExecutionPayloadEnvelope{
+				Message:   fixture.signedProto.Message,
+				Signature: bytes.Repeat([]byte{0xFF}, 96),
+			}
+			badSigned, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
+			require.NoError(t, err)
+
+			err = verifyExecutionPayloadEnvelopeSignature(fixture.state, badSigned)
+			require.ErrorContains(t, "invalid signature format", err)
+		})
+	})
+}

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

@@ -86,6 +86,7 @@ func TestGetSpec(t *testing.T) {
 	config.GloasForkEpoch = 110
 	config.BLSWithdrawalPrefixByte = byte('b')
 	config.ETH1AddressWithdrawalPrefixByte = byte('c')
+	config.BuilderWithdrawalPrefixByte = byte('e')
 	config.GenesisDelay = 24
 	config.SecondsPerSlot = 25
 	config.SlotDurationMilliseconds = 120

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

@@ -113,6 +113,12 @@ func (s *Server) getBeaconStateV2(ctx context.Context, w http.ResponseWriter, id
 			httputil.HandleError(w, errMsgStateFromConsensus+": "+err.Error(), http.StatusInternalServerError)
 			return
 		}
+	case version.Gloas:
+		respSt, err = structs.BeaconStateGloasFromConsensus(st)
+		if err != nil {
+			httputil.HandleError(w, errMsgStateFromConsensus+": "+err.Error(), http.StatusInternalServerError)
+			return
+		}
 	default:
 		httputil.HandleError(w, "Unsupported state version", http.StatusInternalServerError)
 		return

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

@@ -232,6 +232,35 @@ func TestGetBeaconStateV2(t *testing.T) {
 		assert.Equal(t, "123", st.Slot)
 		assert.Equal(t, int(params.BeaconConfig().MinSeedLookahead+1)*int(params.BeaconConfig().SlotsPerEpoch), len(st.ProposerLookahead))
 	})
+	t.Run("Gloas", func(t *testing.T) {
+		fakeState, err := util.NewBeaconStateGloas()
+		require.NoError(t, err)
+		require.NoError(t, fakeState.SetSlot(123))
+		chainService := &blockchainmock.ChainService{}
+		s := &Server{
+			Stater: &testutil.MockStater{
+				BeaconState: fakeState,
+			},
+			HeadFetcher:           chainService,
+			OptimisticModeFetcher: chainService,
+			FinalizationFetcher:   chainService,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
+		request.SetPathValue("state_id", "head")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBeaconStateV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBeaconStateV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Gloas), resp.Version)
+		st := &structs.BeaconStateGloas{}
+		require.NoError(t, json.Unmarshal(resp.Data, st))
+		assert.Equal(t, "123", st.Slot)
+		assert.Equal(t, int(params.BeaconConfig().MinSeedLookahead+1)*int(params.BeaconConfig().SlotsPerEpoch), len(st.ProposerLookahead))
+	})
 	t.Run("execution optimistic", func(t *testing.T) {
 		parentRoot := [32]byte{'a'}
 		blk := util.NewBeaconBlock()
@@ -427,6 +456,78 @@ func TestGetBeaconStateSSZV2(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
 	})
+	t.Run("Electra", func(t *testing.T) {
+		fakeState, err := util.NewBeaconStateElectra()
+		require.NoError(t, err)
+		require.NoError(t, fakeState.SetSlot(123))
+
+		s := &Server{
+			Stater: &testutil.MockStater{
+				BeaconState: fakeState,
+			},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
+		request.SetPathValue("state_id", "head")
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBeaconStateV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Electra), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := fakeState.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+	t.Run("Fulu", func(t *testing.T) {
+		fakeState, err := util.NewBeaconStateFulu()
+		require.NoError(t, err)
+		require.NoError(t, fakeState.SetSlot(123))
+
+		s := &Server{
+			Stater: &testutil.MockStater{
+				BeaconState: fakeState,
+			},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
+		request.SetPathValue("state_id", "head")
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBeaconStateV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Fulu), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := fakeState.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+	t.Run("Gloas", func(t *testing.T) {
+		fakeState, err := util.NewBeaconStateGloas()
+		require.NoError(t, err)
+		require.NoError(t, fakeState.SetSlot(123))
+
+		s := &Server{
+			Stater: &testutil.MockStater{
+				BeaconState: fakeState,
+			},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
+		request.SetPathValue("state_id", "head")
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBeaconStateV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Gloas), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := fakeState.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
 }
 
 func TestGetForkChoiceHeadsV2(t *testing.T) {

beacon-chain/state/interfaces_gloas.go

@@ -1,24 +1,56 @@
 package state
 
 import (
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 )
 
 type writeOnlyGloasFields interface {
+	// Bids.
 	SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error
+
+	// Builder pending payments / withdrawals.
 	SetBuilderPendingPayment(index primitives.Slot, payment *ethpb.BuilderPendingPayment) error
 	ClearBuilderPendingPayment(index primitives.Slot) error
+	QueueBuilderPayment() error
 	RotateBuilderPendingPayments() error
 	AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal) error
+
+	// Execution payload availability.
 	UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val byte) error
+
+	// Misc.
+	SetLatestBlockHash(hash [32]byte) error
+	SetExecutionPayloadAvailability(index primitives.Slot, available bool) error
+
+	// Builders.
+	IncreaseBuilderBalance(index primitives.BuilderIndex, amount uint64) error
+	AddBuilderFromDeposit(pubkey [fieldparams.BLSPubkeyLength]byte, withdrawalCredentials [fieldparams.RootLength]byte, amount uint64) error
 }
 
 type readOnlyGloasFields interface {
+	// Bids.
+	LatestExecutionPayloadBid() (interfaces.ROExecutionPayloadBid, error)
+
+	// Builder pending payments / withdrawals.
+	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
+	WithdrawalsMatchPayloadExpected(withdrawals []*enginev1.Withdrawal) (bool, error)
+	BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error)
+	PayloadExpectedWithdrawals() ([]*enginev1.Withdrawal, error)
+
+	// Misc.
+	LatestBlockHash() ([32]byte, error)
+	ExecutionPayloadAvailability() ([]byte, error)
+
+	// Builders.
+	Builder(index primitives.BuilderIndex) (*ethpb.Builder, error)
+	Builders() ([]*ethpb.Builder, error)
 	BuilderPubkey(primitives.BuilderIndex) ([48]byte, error)
+	BuilderIndexByPubkey(pubkey [fieldparams.BLSPubkeyLength]byte) (primitives.BuilderIndex, bool)
 	IsActiveBuilder(primitives.BuilderIndex) (bool, error)
 	CanBuilderCoverBid(primitives.BuilderIndex, primitives.Gwei) (bool, error)
-	LatestBlockHash() ([32]byte, error)
-	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
+	NextWithdrawalBuilderIndex() (primitives.BuilderIndex, error)
 }

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

@@ -1,11 +1,16 @@
 package state_native
 
 import (
+	"bytes"
 	"fmt"
 
 	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/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
 )
@@ -147,3 +152,138 @@ func (b *BeaconState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment,
 
 	return b.builderPendingPaymentsVal(), nil
 }
+
+// LatestExecutionPayloadBid returns the cached latest execution payload bid for Gloas.
+func (b *BeaconState) LatestExecutionPayloadBid() (interfaces.ROExecutionPayloadBid, error) {
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	if b.latestExecutionPayloadBid == nil {
+		return nil, nil
+	}
+
+	return blocks.WrappedROExecutionPayloadBid(b.latestExecutionPayloadBid.Copy())
+}
+
+// WithdrawalsMatchPayloadExpected returns true if the given withdrawals root matches the state's
+// payload_expected_withdrawals root.
+func (b *BeaconState) WithdrawalsMatchPayloadExpected(withdrawals []*enginev1.Withdrawal) (bool, error) {
+	if b.version < version.Gloas {
+		return false, errNotSupported("WithdrawalsMatchPayloadExpected", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	cfg := params.BeaconConfig()
+
+	withdrawalsRoot, err := ssz.WithdrawalSliceRoot(withdrawals, cfg.MaxWithdrawalsPerPayload)
+	if err != nil {
+		return false, fmt.Errorf("could not compute withdrawals root: %w", err)
+	}
+
+	expected := b.payloadExpectedWithdrawals
+	if expected == nil {
+		expected = []*enginev1.Withdrawal{}
+	}
+	expectedRoot, err := ssz.WithdrawalSliceRoot(expected, cfg.MaxWithdrawalsPerPayload)
+	if err != nil {
+		return false, fmt.Errorf("could not compute expected withdrawals root: %w", err)
+	}
+
+	return withdrawalsRoot == expectedRoot, nil
+}
+
+// Builder returns the builder at the given index.
+func (b *BeaconState) Builder(index primitives.BuilderIndex) (*ethpb.Builder, error) {
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	if b.builders == nil {
+		return nil, nil
+	}
+	if uint64(index) >= uint64(len(b.builders)) {
+		return nil, fmt.Errorf("builder index %d out of bounds", index)
+	}
+	if b.builders[index] == nil {
+		return nil, nil
+	}
+
+	return ethpb.CopyBuilder(b.builders[index]), nil
+}
+
+// BuilderIndexByPubkey returns the builder index for the given pubkey, if present.
+func (b *BeaconState) BuilderIndexByPubkey(pubkey [fieldparams.BLSPubkeyLength]byte) (primitives.BuilderIndex, bool) {
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	for i, builder := range b.builders {
+		if builder == nil {
+			continue
+		}
+		if bytes.Equal(builder.Pubkey, pubkey[:]) {
+			return primitives.BuilderIndex(i), true
+		}
+	}
+	return 0, false
+}
+
+// BuilderPendingWithdrawals returns a copy of the builder pending withdrawals.
+func (b *BeaconState) BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error) {
+	if b.version < version.Gloas {
+		return nil, errNotSupported("BuilderPendingWithdrawals", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.builderPendingWithdrawalsVal(), nil
+}
+
+// Builders returns a copy of the builders registry.
+func (b *BeaconState) Builders() ([]*ethpb.Builder, error) {
+	if b.version < version.Gloas {
+		return nil, errNotSupported("Builders", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.buildersVal(), nil
+}
+
+// NextWithdrawalBuilderIndex returns the next withdrawal builder index.
+func (b *BeaconState) NextWithdrawalBuilderIndex() (primitives.BuilderIndex, error) {
+	if b.version < version.Gloas {
+		return 0, errNotSupported("NextWithdrawalBuilderIndex", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.nextWithdrawalBuilderIndex, nil
+}
+
+// ExecutionPayloadAvailability returns a copy of the execution payload availability.
+func (b *BeaconState) ExecutionPayloadAvailability() ([]byte, error) {
+	if b.version < version.Gloas {
+		return nil, errNotSupported("ExecutionPayloadAvailability", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.executionPayloadAvailabilityVal(), nil
+}
+
+// PayloadExpectedWithdrawals returns a copy of the payload expected withdrawals.
+func (b *BeaconState) PayloadExpectedWithdrawals() ([]*enginev1.Withdrawal, error) {
+	if b.version < version.Gloas {
+		return nil, errNotSupported("PayloadExpectedWithdrawals", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.payloadExpectedWithdrawalsVal(), nil
+}

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

@@ -5,8 +5,10 @@ import (
 	"testing"
 
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
 	"github.com/OffchainLabs/prysm/v7/testing/util"
@@ -166,3 +168,279 @@ func TestBuilderPendingPayments_UnsupportedVersion(t *testing.T) {
 	_, err = st.BuilderPendingPayments()
 	require.ErrorContains(t, "BuilderPendingPayments", err)
 }
+
+func TestBuilderPendingWithdrawals(t *testing.T) {
+	t.Run("returns error before gloas", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.BuilderPendingWithdrawals()
+		require.ErrorContains(t, "BuilderPendingWithdrawals", err)
+	})
+
+	t.Run("returns copy", func(t *testing.T) {
+		original := []*ethpb.BuilderPendingWithdrawal{
+			{Amount: 10, BuilderIndex: 1},
+		}
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			BuilderPendingWithdrawals: original,
+		})
+		require.NoError(t, err)
+
+		got1, err := st.BuilderPendingWithdrawals()
+		require.NoError(t, err)
+		require.DeepEqual(t, original, got1)
+
+		got1[0].Amount = 99
+		got2, err := st.BuilderPendingWithdrawals()
+		require.NoError(t, err)
+		require.DeepEqual(t, original, got2)
+	})
+}
+
+func TestBuildersGetter(t *testing.T) {
+	t.Run("returns error before gloas", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.Builders()
+		require.ErrorContains(t, "Builders", err)
+	})
+
+	t.Run("returns copy", func(t *testing.T) {
+		pubkey := bytes.Repeat([]byte{0xAB}, fieldparams.BLSPubkeyLength)
+		buildr := &ethpb.Builder{
+			Pubkey:            pubkey,
+			Balance:           42,
+			DepositEpoch:      3,
+			WithdrawableEpoch: 4,
+		}
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: []*ethpb.Builder{buildr},
+		})
+		require.NoError(t, err)
+
+		got1, err := st.Builders()
+		require.NoError(t, err)
+		require.DeepEqual(t, buildr, got1[0])
+
+		got1[0].Pubkey[0] = 0xFF
+		got2, err := st.Builders()
+		require.NoError(t, err)
+		require.DeepEqual(t, buildr, got2[0])
+	})
+}
+
+func TestNextWithdrawalBuilderIndex(t *testing.T) {
+	t.Run("returns error before gloas", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.NextWithdrawalBuilderIndex()
+		require.ErrorContains(t, "NextWithdrawalBuilderIndex", err)
+	})
+
+	t.Run("returns configured value", func(t *testing.T) {
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			NextWithdrawalBuilderIndex: 2,
+		})
+		require.NoError(t, err)
+
+		got, err := st.NextWithdrawalBuilderIndex()
+		require.NoError(t, err)
+		require.Equal(t, primitives.BuilderIndex(2), got)
+	})
+}
+
+func TestExecutionPayloadAvailability(t *testing.T) {
+	t.Run("returns error before gloas", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.ExecutionPayloadAvailability()
+		require.ErrorContains(t, "ExecutionPayloadAvailability", err)
+	})
+
+	t.Run("returns copy", func(t *testing.T) {
+		availability := []byte{0x01, 0x00, 0x01}
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			ExecutionPayloadAvailability: availability,
+		})
+		require.NoError(t, err)
+
+		got1, err := st.ExecutionPayloadAvailability()
+		require.NoError(t, err)
+		require.DeepEqual(t, availability, got1)
+
+		got1[0] = 0xFF
+		got2, err := st.ExecutionPayloadAvailability()
+		require.NoError(t, err)
+		require.DeepEqual(t, availability, got2)
+	})
+}
+
+func TestPayloadExpectedWithdrawals(t *testing.T) {
+	t.Run("returns error before gloas", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.PayloadExpectedWithdrawals()
+		require.ErrorContains(t, "PayloadExpectedWithdrawals", err)
+	})
+
+	t.Run("returns copy", func(t *testing.T) {
+		original := enginev1.Withdrawal{
+			Index:          1,
+			ValidatorIndex: 2,
+			Address:        bytes.Repeat([]byte{0x01}, 20),
+			Amount:         10,
+		}
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			PayloadExpectedWithdrawals: []*enginev1.Withdrawal{&original},
+		})
+		require.NoError(t, err)
+
+		got1, err := st.PayloadExpectedWithdrawals()
+		require.NoError(t, err)
+		require.DeepEqual(t, &original, got1[0])
+
+		got1[0].Amount = 99
+		got2, err := st.PayloadExpectedWithdrawals()
+		require.NoError(t, err)
+		require.DeepEqual(t, &original, got2[0])
+	})
+}
+
+func TestWithdrawalsMatchPayloadExpected(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.WithdrawalsMatchPayloadExpected(nil)
+		require.ErrorContains(t, "is not supported", err)
+	})
+
+	t.Run("returns true when roots match", func(t *testing.T) {
+		withdrawals := []*enginev1.Withdrawal{
+			{Index: 0, ValidatorIndex: 1, Address: bytes.Repeat([]byte{0x01}, 20), Amount: 10},
+		}
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			PayloadExpectedWithdrawals: withdrawals,
+		})
+		require.NoError(t, err)
+
+		ok, err := st.WithdrawalsMatchPayloadExpected(withdrawals)
+		require.NoError(t, err)
+		require.Equal(t, true, ok)
+	})
+
+	t.Run("returns false when roots do not match", func(t *testing.T) {
+		expected := []*enginev1.Withdrawal{
+			{Index: 0, ValidatorIndex: 1, Address: bytes.Repeat([]byte{0x01}, 20), Amount: 10},
+		}
+		actual := []*enginev1.Withdrawal{
+			{Index: 0, ValidatorIndex: 1, Address: bytes.Repeat([]byte{0x01}, 20), Amount: 11},
+		}
+
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			PayloadExpectedWithdrawals: expected,
+		})
+		require.NoError(t, err)
+
+		ok, err := st.WithdrawalsMatchPayloadExpected(actual)
+		require.NoError(t, err)
+		require.Equal(t, false, ok)
+	})
+}
+
+func TestBuilder(t *testing.T) {
+	t.Run("nil builders returns nil", func(t *testing.T) {
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: nil,
+		})
+		require.NoError(t, err)
+
+		got, err := st.Builder(0)
+		require.NoError(t, err)
+		require.Equal(t, (*ethpb.Builder)(nil), got)
+	})
+
+	t.Run("out of bounds returns error", func(t *testing.T) {
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: []*ethpb.Builder{{}},
+		})
+		require.NoError(t, err)
+
+		_, err = st.Builder(1)
+		require.ErrorContains(t, "out of bounds", err)
+	})
+
+	t.Run("returns copy", func(t *testing.T) {
+		pubkey := bytes.Repeat([]byte{0xAA}, fieldparams.BLSPubkeyLength)
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: []*ethpb.Builder{
+				{
+					Pubkey:            pubkey,
+					Balance:           42,
+					DepositEpoch:      3,
+					WithdrawableEpoch: 4,
+				},
+			},
+		})
+		require.NoError(t, err)
+
+		got1, err := st.Builder(0)
+		require.NoError(t, err)
+		require.NotEqual(t, (*ethpb.Builder)(nil), got1)
+		require.Equal(t, primitives.Gwei(42), got1.Balance)
+		require.DeepEqual(t, pubkey, got1.Pubkey)
+
+		// Mutate returned builder; state should be unchanged.
+		got1.Pubkey[0] = 0xFF
+		got2, err := st.Builder(0)
+		require.NoError(t, err)
+		require.Equal(t, byte(0xAA), got2.Pubkey[0])
+	})
+}
+
+func TestBuilderIndexByPubkey(t *testing.T) {
+	t.Run("not found returns false", func(t *testing.T) {
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: []*ethpb.Builder{
+				{Pubkey: bytes.Repeat([]byte{0x11}, fieldparams.BLSPubkeyLength)},
+			},
+		})
+		require.NoError(t, err)
+
+		var pk [fieldparams.BLSPubkeyLength]byte
+		copy(pk[:], bytes.Repeat([]byte{0x22}, fieldparams.BLSPubkeyLength))
+		idx, ok := st.BuilderIndexByPubkey(pk)
+		require.Equal(t, false, ok)
+		require.Equal(t, primitives.BuilderIndex(0), idx)
+	})
+
+	t.Run("skips nil entries and finds match", func(t *testing.T) {
+		wantIdx := primitives.BuilderIndex(1)
+		wantPkBytes := bytes.Repeat([]byte{0xAB}, fieldparams.BLSPubkeyLength)
+
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: []*ethpb.Builder{
+				nil,
+				{Pubkey: wantPkBytes},
+			},
+		})
+		require.NoError(t, err)
+
+		var pk [fieldparams.BLSPubkeyLength]byte
+		copy(pk[:], wantPkBytes)
+		idx, ok := st.BuilderIndexByPubkey(pk)
+		require.Equal(t, true, ok)
+		require.Equal(t, wantIdx, idx)
+	})
+}

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

@@ -5,11 +5,14 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stateutil"
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"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/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
 )
 
 // RotateBuilderPendingPayments rotates the queue by dropping slots per epoch payments from the
@@ -121,6 +124,41 @@ func (b *BeaconState) ClearBuilderPendingPayment(index primitives.Slot) error {
 	return nil
 }
 
+// QueueBuilderPayment implements the builder payment queuing logic for Gloas.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// payment = state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH]
+// amount = payment.withdrawal.amount
+// if amount > 0:
+//
+//	state.builder_pending_withdrawals.append(payment.withdrawal)
+//
+// state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH] = BuilderPendingPayment()
+func (b *BeaconState) QueueBuilderPayment() error {
+	if b.version < version.Gloas {
+		return errNotSupported("QueueBuilderPayment", b.version)
+	}
+
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	slot := b.slot
+	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+	paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
+	if uint64(paymentIndex) >= uint64(len(b.builderPendingPayments)) {
+		return fmt.Errorf("builder pending payments index %d out of range (len=%d)", paymentIndex, len(b.builderPendingPayments))
+	}
+
+	payment := b.builderPendingPayments[paymentIndex]
+	if payment != nil && payment.Withdrawal != nil && payment.Withdrawal.Amount > 0 {
+		b.builderPendingWithdrawals = append(b.builderPendingWithdrawals, ethpb.CopyBuilderPendingWithdrawal(payment.Withdrawal))
+		b.markFieldAsDirty(types.BuilderPendingWithdrawals)
+	}
+
+	b.builderPendingPayments[paymentIndex] = emptyBuilderPendingPayment
+	b.markFieldAsDirty(types.BuilderPendingPayments)
+	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 {
@@ -161,3 +199,91 @@ func (b *BeaconState) UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val
 	b.markFieldAsDirty(types.ExecutionPayloadAvailability)
 	return nil
 }
+
+// SetLatestBlockHash sets the latest execution block hash.
+func (b *BeaconState) SetLatestBlockHash(hash [32]byte) error {
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	b.latestBlockHash = hash[:]
+	b.markFieldAsDirty(types.LatestBlockHash)
+	return nil
+}
+
+// SetExecutionPayloadAvailability sets the execution payload availability bit for a specific slot.
+func (b *BeaconState) SetExecutionPayloadAvailability(index primitives.Slot, available bool) error {
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	bitIndex := index % params.BeaconConfig().SlotsPerHistoricalRoot
+	byteIndex := bitIndex / 8
+	bitPosition := bitIndex % 8
+
+	// Set or clear the bit
+	if available {
+		b.executionPayloadAvailability[byteIndex] |= 1 << bitPosition
+	} else {
+		b.executionPayloadAvailability[byteIndex] &^= 1 << bitPosition
+	}
+
+	b.markFieldAsDirty(types.ExecutionPayloadAvailability)
+	return nil
+}
+
+// IncreaseBuilderBalance increases the balance of the builder at the given index.
+func (b *BeaconState) IncreaseBuilderBalance(index primitives.BuilderIndex, amount uint64) error {
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	if b.builders == nil || uint64(index) >= uint64(len(b.builders)) {
+		return fmt.Errorf("builder index %d out of bounds", index)
+	}
+	if b.builders[index] == nil {
+		return fmt.Errorf("builder at index %d is nil", index)
+	}
+
+	builder := ethpb.CopyBuilder(b.builders[index])
+	builder.Balance += primitives.Gwei(amount)
+	b.builders[index] = builder
+
+	b.markFieldAsDirty(types.Builders)
+	return nil
+}
+
+// AddBuilderFromDeposit creates or replaces a builder entry derived from a deposit.
+func (b *BeaconState) AddBuilderFromDeposit(pubkey [fieldparams.BLSPubkeyLength]byte, withdrawalCredentials [fieldparams.RootLength]byte, amount uint64) error {
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	currentEpoch := slots.ToEpoch(b.slot)
+	index := b.builderInsertionIndex(currentEpoch)
+
+	builder := &ethpb.Builder{
+		Pubkey:            bytesutil.SafeCopyBytes(pubkey[:]),
+		Version:           []byte{withdrawalCredentials[0]},
+		ExecutionAddress:  bytesutil.SafeCopyBytes(withdrawalCredentials[12:]),
+		Balance:           primitives.Gwei(amount),
+		DepositEpoch:      currentEpoch,
+		WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
+	}
+
+	if index < primitives.BuilderIndex(len(b.builders)) {
+		b.builders[index] = builder
+	} else {
+		gap := index - primitives.BuilderIndex(len(b.builders)) + 1
+		b.builders = append(b.builders, make([]*ethpb.Builder, gap)...)
+		b.builders[index] = builder
+	}
+
+	b.markFieldAsDirty(types.Builders)
+	return nil
+}
+
+func (b *BeaconState) builderInsertionIndex(currentEpoch primitives.Epoch) primitives.BuilderIndex {
+	for i, builder := range b.builders {
+		if builder.WithdrawableEpoch <= currentEpoch && builder.Balance == 0 {
+			return primitives.BuilderIndex(i)
+		}
+	}
+	return primitives.BuilderIndex(len(b.builders))
+}

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

@@ -181,6 +181,80 @@ func TestClearBuilderPendingPayment(t *testing.T) {
 	})
 }
 
+func TestQueueBuilderPayment(t *testing.T) {
+	t.Run("previous fork returns expected error", func(t *testing.T) {
+		st := &BeaconState{version: version.Fulu}
+		err := st.QueueBuilderPayment()
+		require.ErrorContains(t, "is not supported", err)
+	})
+
+	t.Run("appends withdrawal, clears payment, and marks dirty", func(t *testing.T) {
+		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+		slot := primitives.Slot(3)
+		paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
+
+		st := &BeaconState{
+			version:                   version.Gloas,
+			slot:                      slot,
+			dirtyFields:               make(map[types.FieldIndex]bool),
+			rebuildTrie:               make(map[types.FieldIndex]bool),
+			sharedFieldReferences:     make(map[types.FieldIndex]*stateutil.Reference),
+			builderPendingPayments:    make([]*ethpb.BuilderPendingPayment, slotsPerEpoch*2),
+			builderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{},
+		}
+		st.builderPendingPayments[paymentIndex] = &ethpb.BuilderPendingPayment{
+			Weight: 1,
+			Withdrawal: &ethpb.BuilderPendingWithdrawal{
+				FeeRecipient: bytes.Repeat([]byte{0xAB}, 20),
+				Amount:       99,
+				BuilderIndex: 1,
+			},
+		}
+
+		require.NoError(t, st.QueueBuilderPayment())
+		require.Equal(t, emptyBuilderPendingPayment, st.builderPendingPayments[paymentIndex])
+		require.Equal(t, true, st.dirtyFields[types.BuilderPendingPayments])
+		require.Equal(t, true, st.dirtyFields[types.BuilderPendingWithdrawals])
+		require.Equal(t, 1, len(st.builderPendingWithdrawals))
+		require.DeepEqual(t, bytes.Repeat([]byte{0xAB}, 20), st.builderPendingWithdrawals[0].FeeRecipient)
+		require.Equal(t, primitives.Gwei(99), st.builderPendingWithdrawals[0].Amount)
+
+		// Ensure copied withdrawal is not aliased.
+		st.builderPendingPayments[paymentIndex].Withdrawal.FeeRecipient[0] = 0x01
+		require.Equal(t, byte(0xAB), st.builderPendingWithdrawals[0].FeeRecipient[0])
+	})
+
+	t.Run("zero amount does not append withdrawal", func(t *testing.T) {
+		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+		slot := primitives.Slot(3)
+		paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
+
+		st := &BeaconState{
+			version:                   version.Gloas,
+			slot:                      slot,
+			dirtyFields:               make(map[types.FieldIndex]bool),
+			rebuildTrie:               make(map[types.FieldIndex]bool),
+			sharedFieldReferences:     make(map[types.FieldIndex]*stateutil.Reference),
+			builderPendingPayments:    make([]*ethpb.BuilderPendingPayment, slotsPerEpoch*2),
+			builderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{},
+		}
+		st.builderPendingPayments[paymentIndex] = &ethpb.BuilderPendingPayment{
+			Weight: 1,
+			Withdrawal: &ethpb.BuilderPendingWithdrawal{
+				FeeRecipient: bytes.Repeat([]byte{0xAB}, 20),
+				Amount:       0,
+				BuilderIndex: 1,
+			},
+		}
+
+		require.NoError(t, st.QueueBuilderPayment())
+		require.Equal(t, emptyBuilderPendingPayment, st.builderPendingPayments[paymentIndex])
+		require.Equal(t, true, st.dirtyFields[types.BuilderPendingPayments])
+		require.Equal(t, false, st.dirtyFields[types.BuilderPendingWithdrawals])
+		require.Equal(t, 0, len(st.builderPendingWithdrawals))
+	})
+}
+
 func TestRotateBuilderPendingPayments(t *testing.T) {
 	totalPayments := 2 * params.BeaconConfig().SlotsPerEpoch
 	payments := make([]*ethpb.BuilderPendingPayment, totalPayments)
@@ -328,3 +402,134 @@ func newGloasStateWithAvailability(t *testing.T, availability []byte) *BeaconSta
 
 	return st.(*BeaconState)
 }
+
+func TestSetLatestBlockHash(t *testing.T) {
+	var hash [32]byte
+	copy(hash[:], []byte("latest-block-hash"))
+
+	state := &BeaconState{
+		dirtyFields: make(map[types.FieldIndex]bool),
+	}
+
+	require.NoError(t, state.SetLatestBlockHash(hash))
+	require.Equal(t, true, state.dirtyFields[types.LatestBlockHash])
+	require.DeepEqual(t, hash[:], state.latestBlockHash)
+}
+
+func TestSetExecutionPayloadAvailability(t *testing.T) {
+	state := &BeaconState{
+		executionPayloadAvailability: make([]byte, params.BeaconConfig().SlotsPerHistoricalRoot/8),
+		dirtyFields:                  make(map[types.FieldIndex]bool),
+	}
+
+	slot := primitives.Slot(10)
+	bitIndex := slot % params.BeaconConfig().SlotsPerHistoricalRoot
+	byteIndex := bitIndex / 8
+	bitPosition := bitIndex % 8
+
+	require.NoError(t, state.SetExecutionPayloadAvailability(slot, true))
+	require.Equal(t, true, state.dirtyFields[types.ExecutionPayloadAvailability])
+	require.Equal(t, byte(1<<bitPosition), state.executionPayloadAvailability[byteIndex]&(1<<bitPosition))
+
+	require.NoError(t, state.SetExecutionPayloadAvailability(slot, false))
+	require.Equal(t, byte(0), state.executionPayloadAvailability[byteIndex]&(1<<bitPosition))
+}
+
+func TestIncreaseBuilderBalance(t *testing.T) {
+	t.Run("out of bounds returns error", func(t *testing.T) {
+		st := &BeaconState{
+			version:     version.Gloas,
+			dirtyFields: make(map[types.FieldIndex]bool),
+			builders:    []*ethpb.Builder{},
+		}
+
+		err := st.IncreaseBuilderBalance(0, 1)
+		require.ErrorContains(t, "out of bounds", err)
+		require.Equal(t, false, st.dirtyFields[types.Builders])
+	})
+
+	t.Run("nil builder returns error", func(t *testing.T) {
+		st := &BeaconState{
+			version:     version.Gloas,
+			dirtyFields: make(map[types.FieldIndex]bool),
+			builders:    []*ethpb.Builder{nil},
+		}
+
+		err := st.IncreaseBuilderBalance(0, 1)
+		require.ErrorContains(t, "is nil", err)
+		require.Equal(t, false, st.dirtyFields[types.Builders])
+	})
+
+	t.Run("increments and marks dirty", func(t *testing.T) {
+		orig := &ethpb.Builder{Balance: 10}
+		st := &BeaconState{
+			version:     version.Gloas,
+			dirtyFields: make(map[types.FieldIndex]bool),
+			builders:    []*ethpb.Builder{orig},
+		}
+
+		require.NoError(t, st.IncreaseBuilderBalance(0, 5))
+		require.Equal(t, primitives.Gwei(15), st.builders[0].Balance)
+		require.Equal(t, true, st.dirtyFields[types.Builders])
+		// Copy-on-write semantics: builder pointer replaced.
+		require.NotEqual(t, orig, st.builders[0])
+	})
+}
+
+func TestAddBuilderFromDeposit(t *testing.T) {
+	t.Run("reuses empty withdrawable slot", func(t *testing.T) {
+		var pubkey [48]byte
+		copy(pubkey[:], bytes.Repeat([]byte{0xAA}, 48))
+		var wc [32]byte
+		copy(wc[:], bytes.Repeat([]byte{0xBB}, 32))
+		wc[0] = 0x42 // version byte
+
+		st := &BeaconState{
+			version:     version.Gloas,
+			slot:        0, // epoch 0
+			dirtyFields: make(map[types.FieldIndex]bool),
+			builders: []*ethpb.Builder{
+				{
+					WithdrawableEpoch: 0,
+					Balance:           0,
+				},
+			},
+		}
+
+		require.NoError(t, st.AddBuilderFromDeposit(pubkey, wc, 123))
+		require.Equal(t, 1, len(st.builders))
+		got := st.builders[0]
+		require.NotNil(t, got)
+		require.DeepEqual(t, pubkey[:], got.Pubkey)
+		require.DeepEqual(t, []byte{0x42}, got.Version)
+		require.DeepEqual(t, wc[12:], got.ExecutionAddress)
+		require.Equal(t, primitives.Gwei(123), got.Balance)
+		require.Equal(t, primitives.Epoch(0), got.DepositEpoch)
+		require.Equal(t, params.BeaconConfig().FarFutureEpoch, got.WithdrawableEpoch)
+		require.Equal(t, true, st.dirtyFields[types.Builders])
+	})
+
+	t.Run("appends new builder when no reusable slot", func(t *testing.T) {
+		var pubkey [48]byte
+		copy(pubkey[:], bytes.Repeat([]byte{0xAA}, 48))
+		var wc [32]byte
+		copy(wc[:], bytes.Repeat([]byte{0xBB}, 32))
+
+		st := &BeaconState{
+			version:     version.Gloas,
+			slot:        0,
+			dirtyFields: make(map[types.FieldIndex]bool),
+			builders: []*ethpb.Builder{
+				{
+					WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
+					Balance:           1,
+				},
+			},
+		}
+
+		require.NoError(t, st.AddBuilderFromDeposit(pubkey, wc, 5))
+		require.Equal(t, 2, len(st.builders))
+		require.NotNil(t, st.builders[1])
+		require.Equal(t, primitives.Gwei(5), st.builders[1].Balance)
+	})
+}

changelog/terencechain_add-process-execution-payload-gloas.md

@@ -0,0 +1,2 @@
+### Added
+- Add process execution payload for gloas

config/params/configset_test.go

@@ -98,6 +98,7 @@ func compareConfigs(t *testing.T, expected, actual *BeaconChainConfig) {
 	require.DeepEqual(t, expected.EjectionBalance, actual.EjectionBalance)
 	require.DeepEqual(t, expected.EffectiveBalanceIncrement, actual.EffectiveBalanceIncrement)
 	require.DeepEqual(t, expected.BLSWithdrawalPrefixByte, actual.BLSWithdrawalPrefixByte)
+	require.DeepEqual(t, expected.BuilderWithdrawalPrefixByte, actual.BuilderWithdrawalPrefixByte)
 	require.DeepEqual(t, expected.ZeroHash, actual.ZeroHash)
 	require.DeepEqual(t, expected.GenesisDelay, actual.GenesisDelay)
 	require.DeepEqual(t, expected.MinAttestationInclusionDelay, actual.MinAttestationInclusionDelay)

config/params/loader_test.go

@@ -119,6 +119,7 @@ func assertEqualConfigs(t *testing.T, name string, fields []string, expected, ac
 	// Initial values.
 	assert.DeepEqual(t, expected.GenesisForkVersion, actual.GenesisForkVersion, "%s: GenesisForkVersion", name)
 	assert.DeepEqual(t, expected.BLSWithdrawalPrefixByte, actual.BLSWithdrawalPrefixByte, "%s: BLSWithdrawalPrefixByte", name)
+	assert.DeepEqual(t, expected.BuilderWithdrawalPrefixByte, actual.BuilderWithdrawalPrefixByte, "%s: BuilderWithdrawalPrefixByte", name)
 	assert.DeepEqual(t, expected.ETH1AddressWithdrawalPrefixByte, actual.ETH1AddressWithdrawalPrefixByte, "%s: ETH1AddressWithdrawalPrefixByte", name)
 
 	// Time parameters.

config/params/minimal_config.go

@@ -31,6 +31,7 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	// Initial values
 	minimalConfig.BLSWithdrawalPrefixByte = byte(0)
 	minimalConfig.ETH1AddressWithdrawalPrefixByte = byte(1)
+	minimalConfig.BuilderWithdrawalPrefixByte = byte(3)
 
 	// Time parameters
 	minimalConfig.SecondsPerSlot = 6

config/params/testnet_config_test.go

@@ -54,6 +54,7 @@ func compareConfigs(t *testing.T, expected, actual *params.BeaconChainConfig) {
 	require.DeepEqual(t, expected.EjectionBalance, actual.EjectionBalance)
 	require.DeepEqual(t, expected.EffectiveBalanceIncrement, actual.EffectiveBalanceIncrement)
 	require.DeepEqual(t, expected.BLSWithdrawalPrefixByte, actual.BLSWithdrawalPrefixByte)
+	require.DeepEqual(t, expected.BuilderWithdrawalPrefixByte, actual.BuilderWithdrawalPrefixByte)
 	require.DeepEqual(t, expected.ZeroHash, actual.ZeroHash)
 	require.DeepEqual(t, expected.GenesisDelay, actual.GenesisDelay)
 	require.DeepEqual(t, expected.MinAttestationInclusionDelay, actual.MinAttestationInclusionDelay)

consensus-types/blocks/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "execution.go",
+        "execution_payload_envelope.go",
         "factory.go",
         "get_payload.go",
         "getters.go",
@@ -36,6 +37,7 @@ go_library(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/validator-client:go_default_library",
         "//runtime/version:go_default_library",
+        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
@@ -45,6 +47,7 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
+        "execution_payload_envelope_test.go",
         "execution_test.go",
         "factory_test.go",
         "getters_test.go",

consensus-types/blocks/execution_payload_envelope.go

@@ -0,0 +1,153 @@
+package blocks
+
+import (
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
+	field_params "github.com/OffchainLabs/prysm/v7/config/fieldparams"
+	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"
+	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/ethereum/go-ethereum/common"
+	"google.golang.org/protobuf/proto"
+)
+
+type signedExecutionPayloadEnvelope struct {
+	s *ethpb.SignedExecutionPayloadEnvelope
+}
+
+type executionPayloadEnvelope struct {
+	p *ethpb.ExecutionPayloadEnvelope
+}
+
+// WrappedROSignedExecutionPayloadEnvelope wraps a signed execution payload envelope proto in a read-only interface.
+func WrappedROSignedExecutionPayloadEnvelope(s *ethpb.SignedExecutionPayloadEnvelope) (interfaces.ROSignedExecutionPayloadEnvelope, error) {
+	w := signedExecutionPayloadEnvelope{s: s}
+	if w.IsNil() {
+		return nil, consensus_types.ErrNilObjectWrapped
+	}
+	return w, nil
+}
+
+// WrappedROExecutionPayloadEnvelope wraps an execution payload envelope proto in a read-only interface.
+func WrappedROExecutionPayloadEnvelope(p *ethpb.ExecutionPayloadEnvelope) (interfaces.ROExecutionPayloadEnvelope, error) {
+	w := &executionPayloadEnvelope{p: p}
+	if w.IsNil() {
+		return nil, consensus_types.ErrNilObjectWrapped
+	}
+	return w, nil
+}
+
+// Envelope returns the execution payload envelope as a read-only interface.
+func (s signedExecutionPayloadEnvelope) Envelope() (interfaces.ROExecutionPayloadEnvelope, error) {
+	return WrappedROExecutionPayloadEnvelope(s.s.Message)
+}
+
+// Signature returns the BLS signature as a 96-byte array.
+func (s signedExecutionPayloadEnvelope) Signature() [field_params.BLSSignatureLength]byte {
+	return [field_params.BLSSignatureLength]byte(s.s.Signature)
+}
+
+// IsNil reports whether the signed envelope or its contents are invalid.
+func (s signedExecutionPayloadEnvelope) IsNil() bool {
+	if s.s == nil {
+		return true
+	}
+	if len(s.s.Signature) != field_params.BLSSignatureLength {
+		return true
+	}
+	w := executionPayloadEnvelope{p: s.s.Message}
+	return w.IsNil()
+}
+
+// SigningRoot computes the signing root for the signed envelope with the provided domain.
+func (s signedExecutionPayloadEnvelope) SigningRoot(domain []byte) (root [32]byte, err error) {
+	return signing.ComputeSigningRoot(s.s.Message, domain)
+}
+
+// Proto returns the underlying protobuf message.
+func (s signedExecutionPayloadEnvelope) Proto() proto.Message {
+	return s.s
+}
+
+// IsNil reports whether the envelope or its required fields are invalid.
+func (p *executionPayloadEnvelope) IsNil() bool {
+	if p.p == nil {
+		return true
+	}
+	if p.p.Payload == nil {
+		return true
+	}
+	if len(p.p.BeaconBlockRoot) != field_params.RootLength {
+		return true
+	}
+	if p.p.BlobKzgCommitments == nil {
+		return true
+	}
+	return false
+}
+
+// IsBlinded reports whether the envelope contains a blinded payload.
+func (p *executionPayloadEnvelope) IsBlinded() bool {
+	return !p.IsNil() && p.p.Payload == nil
+}
+
+// Execution returns the execution payload as a read-only interface.
+func (p *executionPayloadEnvelope) Execution() (interfaces.ExecutionData, error) {
+	return WrappedExecutionPayloadDeneb(p.p.Payload)
+}
+
+// ExecutionRequests returns the execution requests attached to the envelope.
+func (p *executionPayloadEnvelope) ExecutionRequests() *enginev1.ExecutionRequests {
+	return p.p.ExecutionRequests
+}
+
+// BuilderIndex returns the proposer/builder index for the envelope.
+func (p *executionPayloadEnvelope) BuilderIndex() primitives.BuilderIndex {
+	return p.p.BuilderIndex
+}
+
+// BeaconBlockRoot returns the beacon block root referenced by the envelope.
+func (p *executionPayloadEnvelope) BeaconBlockRoot() [field_params.RootLength]byte {
+	return [field_params.RootLength]byte(p.p.BeaconBlockRoot)
+}
+
+// BlobKzgCommitments returns a copy of the envelope's KZG commitments.
+func (p *executionPayloadEnvelope) BlobKzgCommitments() [][]byte {
+	commitments := make([][]byte, len(p.p.BlobKzgCommitments))
+	for i, commit := range p.p.BlobKzgCommitments {
+		commitments[i] = make([]byte, len(commit))
+		copy(commitments[i], commit)
+	}
+	return commitments
+}
+
+// VersionedHashes returns versioned hashes derived from the KZG commitments.
+func (p *executionPayloadEnvelope) VersionedHashes() []common.Hash {
+	commitments := p.p.BlobKzgCommitments
+	versionedHashes := make([]common.Hash, len(commitments))
+	for i, commitment := range commitments {
+		versionedHashes[i] = primitives.ConvertKzgCommitmentToVersionedHash(commitment)
+	}
+	return versionedHashes
+}
+
+// BlobKzgCommitmentsRoot returns the SSZ root of the envelope's KZG commitments.
+func (p *executionPayloadEnvelope) BlobKzgCommitmentsRoot() ([field_params.RootLength]byte, error) {
+	if p.IsNil() || p.p.BlobKzgCommitments == nil {
+		return [field_params.RootLength]byte{}, consensus_types.ErrNilObjectWrapped
+	}
+
+	return ssz.KzgCommitmentsRoot(p.p.BlobKzgCommitments)
+}
+
+// Slot returns the slot of the envelope.
+func (p *executionPayloadEnvelope) Slot() primitives.Slot {
+	return p.p.Slot
+}
+
+// StateRoot returns the state root carried by the envelope.
+func (p *executionPayloadEnvelope) StateRoot() [field_params.RootLength]byte {
+	return [field_params.RootLength]byte(p.p.StateRoot)
+}

consensus-types/blocks/execution_payload_envelope_test.go

@@ -0,0 +1,115 @@
+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"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/assert"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+)
+
+func validExecutionPayloadEnvelope() *ethpb.ExecutionPayloadEnvelope {
+	payload := &enginev1.ExecutionPayloadDeneb{
+		ParentHash:    bytes.Repeat([]byte{0x01}, 32),
+		FeeRecipient:  bytes.Repeat([]byte{0x02}, 20),
+		StateRoot:     bytes.Repeat([]byte{0x03}, 32),
+		ReceiptsRoot:  bytes.Repeat([]byte{0x04}, 32),
+		LogsBloom:     bytes.Repeat([]byte{0x05}, 256),
+		PrevRandao:    bytes.Repeat([]byte{0x06}, 32),
+		BlockNumber:   1,
+		GasLimit:      2,
+		GasUsed:       3,
+		Timestamp:     4,
+		BaseFeePerGas: bytes.Repeat([]byte{0x07}, 32),
+		BlockHash:     bytes.Repeat([]byte{0x08}, 32),
+		Transactions:  [][]byte{},
+		Withdrawals:   []*enginev1.Withdrawal{},
+		BlobGasUsed:   0,
+		ExcessBlobGas: 0,
+	}
+
+	return &ethpb.ExecutionPayloadEnvelope{
+		Payload:            payload,
+		ExecutionRequests:  &enginev1.ExecutionRequests{},
+		BuilderIndex:       10,
+		BeaconBlockRoot:    bytes.Repeat([]byte{0xAA}, 32),
+		Slot:               9,
+		BlobKzgCommitments: [][]byte{bytes.Repeat([]byte{0x0C}, 48)},
+		StateRoot:          bytes.Repeat([]byte{0xBB}, 32),
+	}
+}
+
+func TestWrappedROExecutionPayloadEnvelope(t *testing.T) {
+	t.Run("returns error on invalid beacon root length", func(t *testing.T) {
+		invalid := validExecutionPayloadEnvelope()
+		invalid.BeaconBlockRoot = []byte{0x01}
+		_, err := blocks.WrappedROExecutionPayloadEnvelope(invalid)
+		require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
+	})
+
+	t.Run("wraps and exposes fields", func(t *testing.T) {
+		env := validExecutionPayloadEnvelope()
+		wrapped, err := blocks.WrappedROExecutionPayloadEnvelope(env)
+		require.NoError(t, err)
+
+		require.Equal(t, primitives.BuilderIndex(10), wrapped.BuilderIndex())
+		require.Equal(t, primitives.Slot(9), wrapped.Slot())
+		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xAA}, 32)), wrapped.BeaconBlockRoot())
+		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xBB}, 32)), wrapped.StateRoot())
+
+		commitments := wrapped.BlobKzgCommitments()
+		assert.DeepEqual(t, env.BlobKzgCommitments, commitments)
+
+		versioned := wrapped.VersionedHashes()
+		require.Equal(t, 1, len(versioned))
+
+		reqs := wrapped.ExecutionRequests()
+		require.NotNil(t, reqs)
+
+		exec, err := wrapped.Execution()
+		require.NoError(t, err)
+		assert.DeepEqual(t, env.Payload.ParentHash, exec.ParentHash())
+	})
+}
+
+func TestWrappedROSignedExecutionPayloadEnvelope(t *testing.T) {
+	t.Run("returns error for invalid signature length", func(t *testing.T) {
+		signed := &ethpb.SignedExecutionPayloadEnvelope{
+			Message:   validExecutionPayloadEnvelope(),
+			Signature: bytes.Repeat([]byte{0xAA}, 95),
+		}
+		_, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signed)
+		require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
+	})
+
+	t.Run("wraps and provides envelope/signing data", func(t *testing.T) {
+		sig := bytes.Repeat([]byte{0xAB}, 96)
+		signed := &ethpb.SignedExecutionPayloadEnvelope{
+			Message:   validExecutionPayloadEnvelope(),
+			Signature: sig,
+		}
+
+		wrapped, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signed)
+		require.NoError(t, err)
+
+		gotSig := wrapped.Signature()
+		assert.DeepEqual(t, [96]byte(sig), gotSig)
+
+		env, err := wrapped.Envelope()
+		require.NoError(t, err)
+		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xAA}, 32)), env.BeaconBlockRoot())
+
+		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/blocks/signed_execution_bid.go

@@ -111,7 +111,7 @@ func (h executionPayloadBidGloas) GasLimit() uint64 {
 	return h.payload.GasLimit
 }
 
-// BuilderIndex returns the validator index of the builder who created this bid.
+// BuilderIndex returns the builder index of the builder who created this bid.
 func (h executionPayloadBidGloas) BuilderIndex() primitives.BuilderIndex {
 	return h.payload.BuilderIndex
 }

consensus-types/interfaces/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "beacon_block.go",
         "error.go",
+        "execution_payload_envelope.go",
         "light_client.go",
         "signed_execution_payload_bid.go",
         "utils.go",
@@ -19,6 +20,7 @@ go_library(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/validator-client:go_default_library",
         "//runtime/version:go_default_library",
+        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",

consensus-types/interfaces/execution_payload_envelope.go

@@ -0,0 +1,31 @@
+package interfaces
+
+import (
+	field_params "github.com/OffchainLabs/prysm/v7/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	"github.com/ethereum/go-ethereum/common"
+	"google.golang.org/protobuf/proto"
+)
+
+type ROSignedExecutionPayloadEnvelope interface {
+	Envelope() (ROExecutionPayloadEnvelope, error)
+	Signature() [field_params.BLSSignatureLength]byte
+	SigningRoot([]byte) ([32]byte, error)
+	IsNil() bool
+	Proto() proto.Message
+}
+
+type ROExecutionPayloadEnvelope interface {
+	Execution() (ExecutionData, error)
+	ExecutionRequests() *enginev1.ExecutionRequests
+	BuilderIndex() primitives.BuilderIndex
+	BeaconBlockRoot() [field_params.RootLength]byte
+	BlobKzgCommitments() [][]byte
+	BlobKzgCommitmentsRoot() ([field_params.RootLength]byte, error)
+	VersionedHashes() []common.Hash
+	Slot() primitives.Slot
+	StateRoot() [field_params.RootLength]byte
+	IsBlinded() bool
+	IsNil() bool
+}

encoding/ssz/htrutils.go

@@ -5,6 +5,7 @@ import (
 	"encoding/binary"
 
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v7/crypto/hash/htr"
 	"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"
@@ -141,3 +142,24 @@ func withdrawalRoot(w *enginev1.Withdrawal) ([32]byte, error) {
 	}
 	return w.HashTreeRoot()
 }
+
+// KzgCommitmentsRoot computes the HTR for a list of KZG commitments
+func KzgCommitmentsRoot(commitments [][]byte) ([32]byte, error) {
+	roots := make([][32]byte, len(commitments))
+	for i, commitment := range commitments {
+		chunks, err := PackByChunk([][]byte{commitment})
+		if err != nil {
+			return [32]byte{}, err
+		}
+		roots[i] = htr.VectorizedSha256(chunks)[0]
+	}
+
+	commitmentsRoot, err := BitwiseMerkleize(roots, uint64(len(roots)), fieldparams.MaxBlobCommitmentsPerBlock)
+	if err != nil {
+		return [32]byte{}, errors.Wrap(err, "could not compute merkleization")
+	}
+
+	length := make([]byte, 32)
+	binary.LittleEndian.PutUint64(length[:8], uint64(len(roots)))
+	return MixInLength(commitmentsRoot, length), nil
+}

testing/spectest/mainnet/BUILD.bazel

@@ -202,6 +202,7 @@ go_test(
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
         "gloas__operations__execution_payload_header_test.go",
+        "gloas__operations__execution_payload_test.go",
         "gloas__operations__payload_attestation_test.go",
         "gloas__operations__proposer_slashing_test.go",
         "gloas__sanity__slots_test.go",

testing/spectest/mainnet/gloas__operations__execution_payload_test.go

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

testing/spectest/minimal/BUILD.bazel

@@ -208,6 +208,7 @@ go_test(
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
         "gloas__operations__execution_payload_bid_test.go",
+        "gloas__operations__execution_payload_test.go",
         "gloas__operations__payload_attestation_test.go",
         "gloas__operations__proposer_slashing_test.go",
         "gloas__sanity__slots_test.go",

testing/spectest/minimal/gloas__operations__execution_payload_test.go

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

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

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     testonly = True,
     srcs = [
+        "execution_payload.go",
         "execution_payload_bid.go",
         "helpers.go",
         "payload_attestation.go",
@@ -12,12 +13,23 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations",
     visibility = ["//visibility:public"],
     deps = [
+        "//beacon-chain/core/gloas:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
+        "//config/params: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/require:go_default_library",
         "//testing/spectest/shared/common/operations:go_default_library",
+        "//testing/spectest/utils:go_default_library",
+        "//testing/util:go_default_library",
+        "@com_github_golang_snappy//:go_default_library",
+        "@com_github_google_go_cmp//cmp:go_default_library",
+        "@io_bazel_rules_go//go/tools/bazel:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
+        "@org_golang_google_protobuf//testing/protocmp:go_default_library",
     ],
 )

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

@@ -0,0 +1,123 @@
+package operations
+
+import (
+	"context"
+	"os"
+	"path"
+	"strings"
+	"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/config/params"
+	"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"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/utils"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+	"github.com/bazelbuild/rules_go/go/tools/bazel"
+	"github.com/golang/snappy"
+	"github.com/google/go-cmp/cmp"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/testing/protocmp"
+)
+
+type ExecutionConfig struct {
+	Valid bool `json:"execution_valid"`
+}
+
+func sszToSignedExecutionPayloadEnvelope(b []byte) (interfaces.ROSignedExecutionPayloadEnvelope, error) {
+	envelope := &ethpb.SignedExecutionPayloadEnvelope{}
+	if err := envelope.UnmarshalSSZ(b); err != nil {
+		return nil, err
+	}
+	return blocks.WrappedROSignedExecutionPayloadEnvelope(envelope)
+}
+
+func RunExecutionPayloadTest(t *testing.T, config string) {
+	require.NoError(t, utils.SetConfig(t, config))
+	cfg := params.BeaconConfig()
+	params.SetGenesisFork(t, cfg, version.Fulu)
+	testFolders, testsFolderPath := utils.TestFolders(t, config, "gloas", "operations/execution_payload/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, "gloas", "operations/execution_payload/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			helpers.ClearCache()
+
+			// Check if signed_envelope.ssz_snappy exists, skip if not
+			_, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "signed_envelope.ssz_snappy"))
+			if err != nil && strings.Contains(err.Error(), "could not locate file") {
+				t.Skipf("Skipping test %s: signed_envelope.ssz_snappy not found", folder.Name())
+				return
+			}
+
+			// Read the signed execution payload envelope
+			envelopeFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "signed_envelope.ssz_snappy")
+			require.NoError(t, err)
+			envelopeSSZ, err := snappy.Decode(nil /* dst */, envelopeFile)
+			require.NoError(t, err, "Failed to decompress envelope")
+			signedEnvelope, err := sszToSignedExecutionPayloadEnvelope(envelopeSSZ)
+			require.NoError(t, err, "Failed to unmarshal signed envelope")
+
+			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
+			require.NoError(t, err)
+			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
+			require.NoError(t, err, "Failed to decompress")
+			preBeaconState, err := sszToState(preBeaconStateSSZ)
+			require.NoError(t, err)
+
+			postSSZFilepath, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "post.ssz_snappy"))
+			postSSZExists := true
+			if err != nil && strings.Contains(err.Error(), "could not locate file") {
+				postSSZExists = false
+			} else {
+				require.NoError(t, err)
+			}
+
+			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "execution.yaml")
+			require.NoError(t, err)
+			config := &ExecutionConfig{}
+			require.NoError(t, utils.UnmarshalYaml(file, config), "Failed to Unmarshal")
+			if !config.Valid {
+				t.Skip("Skipping invalid execution engine test as it's never supported")
+			}
+
+			err = gloas.ProcessExecutionPayload(context.Background(), preBeaconState, signedEnvelope)
+			if postSSZExists {
+				require.NoError(t, err)
+				comparePostState(t, postSSZFilepath, preBeaconState)
+			} else if config.Valid {
+				// Note: This doesn't test anything worthwhile. It essentially tests
+				// that *any* error has occurred, not any specific error.
+				if err == nil {
+					t.Fatal("Did not fail when expected")
+				}
+				t.Logf("Expected failure; failure reason = %v", err)
+				return
+			}
+		})
+	}
+}
+
+func comparePostState(t *testing.T, postSSZFilepath string, want state.BeaconState) {
+	postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
+	require.NoError(t, err)
+	postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
+	require.NoError(t, err, "Failed to decompress")
+	postBeaconState, err := sszToState(postBeaconStateSSZ)
+	require.NoError(t, err)
+	postBeaconStatePb, ok := postBeaconState.ToProtoUnsafe().(proto.Message)
+	require.Equal(t, true, ok, "post beacon state did not return a proto.Message")
+	pbState, ok := want.ToProtoUnsafe().(proto.Message)
+	require.Equal(t, true, ok, "beacon state did not return a proto.Message")
+
+	if !proto.Equal(postBeaconStatePb, pbState) {
+		diff := cmp.Diff(pbState, postBeaconStatePb, protocmp.Transform())
+		t.Fatalf("Post state does not match expected state, diff: %s", diff)
+	}
+}