Potuz's code suggestion

beacon-chain/core/altair/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
+        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",

beacon-chain/core/altair/attestation.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
+	"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/core/time"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
@@ -75,7 +76,11 @@ func ProcessAttestationNoVerifySignature(
 		return nil, err
 	}
 
-	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance)
+	if err := beaconState.UpdatePendingPaymentWeight(att, indices, participatedFlags); err != nil {
+		return nil, errors.Wrap(err, "failed to update pending payment weight")
+	}
+
+	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance, att)
 }
 
 // SetParticipationAndRewardProposer retrieves and sets the epoch participation bits in state. Based on the epoch participation, it rewards
@@ -105,7 +110,9 @@ func SetParticipationAndRewardProposer(
 	beaconState state.BeaconState,
 	targetEpoch primitives.Epoch,
 	indices []uint64,
-	participatedFlags map[uint8]bool, totalBalance uint64) (state.BeaconState, error) {
+	participatedFlags map[uint8]bool,
+	totalBalance uint64,
+	att ethpb.Att) (state.BeaconState, error) {
 	var proposerRewardNumerator uint64
 	currentEpoch := time.CurrentEpoch(beaconState)
 	var stateErr error
@@ -299,6 +306,19 @@ func AttestationParticipationFlagIndices(beaconState state.ReadOnlyBeaconState,
 		participatedFlags[targetFlagIndex] = true
 	}
 	matchedSrcTgtHead := matchedHead && matchedSrcTgt
+
+	var beaconBlockRoot [32]byte
+	copy(beaconBlockRoot[:], data.BeaconBlockRoot)
+	matchingPayload, err := gloas.MatchingPayload(
+		beaconState,
+		beaconBlockRoot,
+		data.Slot,
+		uint64(data.CommitteeIndex),
+	)
+	if err != nil {
+		return nil, err
+	}
+	matchedSrcTgtHead = matchedSrcTgtHead && matchingPayload
 	if matchedSrcTgtHead && delay == cfg.MinAttestationInclusionDelay {
 		participatedFlags[headFlagIndex] = true
 	}

beacon-chain/core/altair/attestation_test.go

@@ -1,7 +1,9 @@
 package altair_test
 
 import (
+	"bytes"
 	"fmt"
+	"reflect"
 	"testing"
 
 	"github.com/OffchainLabs/go-bitfield"
@@ -556,7 +558,7 @@ func TestSetParticipationAndRewardProposer(t *testing.T) {
 
 			b, err := helpers.TotalActiveBalance(beaconState)
 			require.NoError(t, err)
-			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b)
+			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b, &ethpb.Attestation{})
 			require.NoError(t, err)
 
 			i, err := helpers.BeaconProposerIndex(t.Context(), st)
@@ -775,11 +777,67 @@ func TestAttestationParticipationFlagIndices(t *testing.T) {
 				headFlagIndex:   true,
 			},
 		},
+		{
+			name: "gloas same-slot committee index non-zero errors",
+			inputState: func() state.BeaconState {
+				stateSlot := primitives.Slot(5)
+				slot := primitives.Slot(3)
+				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
+				headRoot := bytes.Repeat([]byte{0xBB}, 32)
+				prevRoot := bytes.Repeat([]byte{0xCC}, 32)
+				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, prevRoot, 0, 0)
+			}(),
+			inputData: &ethpb.AttestationData{
+				Slot:            3,
+				CommitteeIndex:  1, // invalid for same-slot
+				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
+				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
+				Target: &ethpb.Checkpoint{
+					Epoch: 0,
+					Root:  bytes.Repeat([]byte{0xAA}, 32),
+				},
+			},
+			inputDelay:           1,
+			participationIndices: nil,
+		},
+		{
+			name: "gloas payload availability matches committee index",
+			inputState: func() state.BeaconState {
+				stateSlot := primitives.Slot(5)
+				slot := primitives.Slot(3)
+				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
+				headRoot := bytes.Repeat([]byte{0xBB}, 32)
+				// Same prev root to make SameSlotAttestation false and use payload availability.
+				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, headRoot, 1, slot)
+			}(),
+			inputData: &ethpb.AttestationData{
+				Slot:            3,
+				CommitteeIndex:  1,
+				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
+				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
+				Target: &ethpb.Checkpoint{
+					Epoch: 0,
+					Root:  bytes.Repeat([]byte{0xAA}, 32),
+				},
+			},
+			inputDelay: 1,
+			participationIndices: map[uint8]bool{
+				sourceFlagIndex: true,
+				targetFlagIndex: true,
+				headFlagIndex:   true,
+			},
+		},
 	}
 	for _, test := range tests {
 		flagIndices, err := altair.AttestationParticipationFlagIndices(test.inputState, test.inputData, test.inputDelay)
+		if test.participationIndices == nil {
+			require.ErrorContains(t, "committee index", err)
+			continue
+		}
 		require.NoError(t, err)
-		require.DeepEqual(t, test.participationIndices, flagIndices)
+		if !reflect.DeepEqual(test.participationIndices, flagIndices) {
+			t.Fatalf("unexpected participation indices: got %v want %v", flagIndices, test.participationIndices)
+		}
 	}
 }
 
@@ -858,3 +916,61 @@ func TestMatchingStatus(t *testing.T) {
 		require.Equal(t, test.matchedHead, head)
 	}
 }
+
+func buildGloasStateForFlags(t *testing.T, stateSlot, slot primitives.Slot, targetRoot, headRoot, prevRoot []byte, availabilityBit uint8, availabilitySlot primitives.Slot) state.BeaconState {
+	t.Helper()
+
+	cfg := params.BeaconConfig()
+	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	blockRoots[0] = targetRoot
+	blockRoots[slot%cfg.SlotsPerHistoricalRoot] = headRoot
+	blockRoots[(slot-1)%cfg.SlotsPerHistoricalRoot] = prevRoot
+
+	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for i := range stateRoots {
+		stateRoots[i] = make([]byte, fieldparams.RootLength)
+	}
+	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
+	for i := range randaoMixes {
+		randaoMixes[i] = make([]byte, fieldparams.RootLength)
+	}
+
+	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
+	idx := availabilitySlot % cfg.SlotsPerHistoricalRoot
+	byteIndex := idx / 8
+	bitIndex := idx % 8
+	if availabilityBit == 1 {
+		execPayloadAvailability[byteIndex] |= 1 << bitIndex
+	}
+
+	checkpointRoot := bytes.Repeat([]byte{0xDD}, fieldparams.RootLength)
+	justified := &ethpb.Checkpoint{Root: checkpointRoot}
+
+	stProto := &ethpb.BeaconStateGloas{
+		Slot:                         stateSlot,
+		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
+		BlockRoots:                   blockRoots,
+		StateRoots:                   stateRoots,
+		RandaoMixes:                  randaoMixes,
+		ExecutionPayloadAvailability: execPayloadAvailability,
+		CurrentJustifiedCheckpoint:   justified,
+		PreviousJustifiedCheckpoint:  justified,
+		Validators: []*ethpb.Validator{
+			{
+				EffectiveBalance:      cfg.MinActivationBalance,
+				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
+			},
+		},
+		Balances:               []uint64{cfg.MinActivationBalance},
+		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
+		Fork: &ethpb.Fork{
+			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
+			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
+			Epoch:           0,
+		},
+	}
+
+	beaconState, err := state_native.InitializeFromProtoGloas(stProto)
+	require.NoError(t, err)
+	return beaconState
+}

beacon-chain/core/blocks/attestation.go

@@ -111,10 +111,21 @@ func VerifyAttestationNoVerifySignature(
 	var indexedAtt ethpb.IndexedAtt
 
 	if att.Version() >= version.Electra {
-		if att.GetData().CommitteeIndex != 0 {
-			return errors.New("committee index must be 0 post-Electra")
+		ci := att.GetData().CommitteeIndex
+		// Spec v1.7.0-alpha pseudocode:
+		//
+		//	# [Modified in Gloas:EIP7732]
+		//	assert data.index < 2
+		//
+		if beaconState.Version() >= version.Gloas {
+			if ci >= 2 {
+				return fmt.Errorf("incorrect committee index %d", ci)
+			}
+		} else {
+			if ci != 0 {
+				return errors.New("committee index must be 0 between Electra and Gloas forks")
+			}
 		}
-
 		aggBits := att.GetAggregationBits()
 		committeeIndices := att.CommitteeBitsVal().BitIndices()
 		committees := make([][]primitives.ValidatorIndex, len(committeeIndices))

beacon-chain/core/blocks/attestation_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"bytes"
 	"context"
 	"testing"
 
@@ -262,7 +263,7 @@ func TestVerifyAttestationNoVerifySignature_Electra(t *testing.T) {
 			CommitteeBits:   bitfield.NewBitvector64(),
 		}
 		err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
-		assert.ErrorContains(t, "committee index must be 0 post-Electra", err)
+		assert.ErrorContains(t, "committee index must be 0", err)
 	})
 	t.Run("index of committee too big", func(t *testing.T) {
 		aggBits := bitfield.NewBitlist(3)
@@ -314,6 +315,75 @@ func TestVerifyAttestationNoVerifySignature_Electra(t *testing.T) {
 	})
 }
 
+func TestVerifyAttestationNoVerifySignature_GloasCommitteeIndexLimit(t *testing.T) {
+	cfg := params.BeaconConfig()
+	stateSlot := cfg.MinAttestationInclusionDelay + 1
+
+	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for i := range blockRoots {
+		blockRoots[i] = make([]byte, fieldparams.RootLength)
+	}
+	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for i := range stateRoots {
+		stateRoots[i] = make([]byte, fieldparams.RootLength)
+	}
+	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
+	for i := range randaoMixes {
+		randaoMixes[i] = make([]byte, fieldparams.RootLength)
+	}
+
+	checkpointRoot := bytes.Repeat([]byte{0xAA}, fieldparams.RootLength)
+	justified := &ethpb.Checkpoint{Epoch: 0, Root: checkpointRoot}
+
+	gloasStateProto := &ethpb.BeaconStateGloas{
+		Slot:                         stateSlot,
+		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
+		BlockRoots:                   blockRoots,
+		StateRoots:                   stateRoots,
+		RandaoMixes:                  randaoMixes,
+		ExecutionPayloadAvailability: make([]byte, cfg.SlotsPerHistoricalRoot/8),
+		CurrentJustifiedCheckpoint:   justified,
+		PreviousJustifiedCheckpoint:  justified,
+		Validators: []*ethpb.Validator{
+			{
+				EffectiveBalance:      cfg.MinActivationBalance,
+				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
+			},
+		},
+		Balances:               []uint64{cfg.MinActivationBalance},
+		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
+		Fork: &ethpb.Fork{
+			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
+			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
+			Epoch:           0,
+		},
+	}
+
+	beaconState, err := state_native.InitializeFromProtoGloas(gloasStateProto)
+	require.NoError(t, err)
+
+	committeeBits := bitfield.NewBitvector64()
+	committeeBits.SetBitAt(0, true)
+	aggBits := bitfield.NewBitlist(1)
+	aggBits.SetBitAt(0, true)
+
+	att := &ethpb.AttestationElectra{
+		Data: &ethpb.AttestationData{
+			Slot:            0,
+			CommitteeIndex:  2, // invalid for Gloas (must be <2)
+			BeaconBlockRoot: blockRoots[0],
+			Source:          justified,
+			Target:          justified,
+		},
+		AggregationBits: aggBits,
+		CommitteeBits:   committeeBits,
+		Signature:       bytes.Repeat([]byte{0x00}, fieldparams.BLSSignatureLength),
+	}
+
+	err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
+	assert.ErrorContains(t, "incorrect committee index 2", err)
+}
+
 func TestConvertToIndexed_OK(t *testing.T) {
 	helpers.ClearCache()
 	validators := make([]*ethpb.Validator, 2*params.BeaconConfig().SlotsPerEpoch)
@@ -583,6 +653,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 }
 
 func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing.T) {
+	helpers.ClearCache()
 	ctx := t.Context()
 	numOfValidators := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))
 	validators := make([]*ethpb.Validator, numOfValidators)

beacon-chain/core/gloas/BUILD.bazel

@@ -3,11 +3,10 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "attestation.go",
         "bid.go",
-        "builder.go",
         "pending_payment.go",
         "proposer_slashing.go",
-        "withdrawal.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
     visibility = ["//visibility:public"],
@@ -23,6 +22,7 @@ go_library(
         "//crypto/bls:go_default_library",
         "//crypto/bls/common:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
@@ -31,6 +31,7 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
+        "attestation_test.go",
         "bid_test.go",
         "pending_payment_test.go",
         "proposer_slashing_test.go",

beacon-chain/core/gloas/attestation.go

@@ -0,0 +1,52 @@
+package gloas
+
+import (
+	"fmt"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/pkg/errors"
+)
+
+// MatchingPayload returns true if the attestation's committee index matches the expected payload index.
+//
+// For pre-Gloas forks, this always returns true.
+//
+// Spec v1.7.0-alpha (pseudocode):
+//
+//	# [New in Gloas:EIP7732]
+//	if is_attestation_same_slot(state, data):
+//	    assert data.index == 0
+//	    payload_matches = True
+//	else:
+//	    slot_index = data.slot % SLOTS_PER_HISTORICAL_ROOT
+//	    payload_index = state.execution_payload_availability[slot_index]
+//	    payload_matches = data.index == payload_index
+func MatchingPayload(
+	beaconState state.ReadOnlyBeaconState,
+	beaconBlockRoot [32]byte,
+	slot primitives.Slot,
+	committeeIndex uint64,
+) (bool, error) {
+	if beaconState.Version() < version.Gloas {
+		return true, nil
+	}
+
+	sameSlot, err := beaconState.IsAttestationSameSlot(beaconBlockRoot, slot)
+	if err != nil {
+		return false, errors.Wrap(err, "failed to get same slot attestation status")
+	}
+	if sameSlot {
+		if committeeIndex != 0 {
+			return false, fmt.Errorf("committee index %d for same slot attestation must be 0", committeeIndex)
+		}
+		return true, nil
+	}
+
+	executionPayloadAvail, err := beaconState.ExecutionPayloadAvailability(slot)
+	if err != nil {
+		return false, errors.Wrap(err, "failed to get execution payload availability status")
+	}
+	return executionPayloadAvail == committeeIndex, nil
+}

beacon-chain/core/gloas/attestation_test.go

@@ -0,0 +1,110 @@
+package gloas
+
+import (
+	"bytes"
+	"testing"
+
+	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+)
+
+func buildStateWithBlockRoots(t *testing.T, stateSlot primitives.Slot, roots map[primitives.Slot][]byte) *state_native.BeaconState {
+	t.Helper()
+
+	cfg := params.BeaconConfig()
+	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for slot, root := range roots {
+		blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
+	}
+
+	stProto := &ethpb.BeaconStateGloas{
+		Slot:       stateSlot,
+		BlockRoots: blockRoots,
+	}
+
+	state, err := state_native.InitializeFromProtoGloas(stProto)
+	require.NoError(t, err)
+	return state.(*state_native.BeaconState)
+}
+
+func TestMatchingPayload(t *testing.T) {
+	t.Run("pre-gloas always true", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+
+		ok, err := MatchingPayload(stIface, [32]byte{}, 0, 123)
+		require.NoError(t, err)
+		require.Equal(t, true, ok)
+	})
+
+	t.Run("same slot requires committee index 0", func(t *testing.T) {
+		root := bytes.Repeat([]byte{0xAA}, 32)
+		state := buildStateWithBlockRoots(t, 6, map[primitives.Slot][]byte{
+			4: root,
+			3: bytes.Repeat([]byte{0xBB}, 32),
+		})
+
+		var rootArr [32]byte
+		copy(rootArr[:], root)
+
+		ok, err := MatchingPayload(state, rootArr, 4, 1)
+		require.ErrorContains(t, "committee index", err)
+		require.Equal(t, false, ok)
+	})
+
+	t.Run("same slot matches when committee index is 0", func(t *testing.T) {
+		root := bytes.Repeat([]byte{0xAA}, 32)
+		state := buildStateWithBlockRoots(t, 6, map[primitives.Slot][]byte{
+			4: root,
+			3: bytes.Repeat([]byte{0xBB}, 32),
+		})
+
+		var rootArr [32]byte
+		copy(rootArr[:], root)
+
+		ok, err := MatchingPayload(state, rootArr, 4, 0)
+		require.NoError(t, err)
+		require.Equal(t, true, ok)
+	})
+
+	t.Run("non same slot checks payload availability", func(t *testing.T) {
+		cfg := params.BeaconConfig()
+		root := bytes.Repeat([]byte{0xAA}, 32)
+		blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+		blockRoots[4%cfg.SlotsPerHistoricalRoot] = bytes.Repeat([]byte{0xCC}, 32)
+		blockRoots[3%cfg.SlotsPerHistoricalRoot] = bytes.Repeat([]byte{0xBB}, 32)
+
+		availability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
+		slotIndex := uint64(4)
+		availability[slotIndex/8] = byte(1 << (slotIndex % 8))
+
+		stIface, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Slot:                         6,
+			BlockRoots:                   blockRoots,
+			ExecutionPayloadAvailability: availability,
+			Fork: &ethpb.Fork{
+				CurrentVersion:  bytes.Repeat([]byte{0x66}, 4),
+				PreviousVersion: bytes.Repeat([]byte{0x66}, 4),
+				Epoch:           0,
+			},
+		})
+		require.NoError(t, err)
+		state := stIface.(*state_native.BeaconState)
+		require.Equal(t, version.Gloas, state.Version())
+
+		var rootArr [32]byte
+		copy(rootArr[:], root)
+
+		ok, err := MatchingPayload(state, rootArr, 4, 1)
+		require.NoError(t, err)
+		require.Equal(t, true, ok)
+
+		ok, err = MatchingPayload(state, rootArr, 4, 0)
+		require.NoError(t, err)
+		require.Equal(t, false, ok)
+	})
+}

beacon-chain/core/gloas/bid_test.go

@@ -203,7 +203,7 @@ func TestProcessExecutionPayloadBid_SelfBuildSuccess(t *testing.T) {
 		Slot:                   slot,
 		Value:                  0,
 		ExecutionPayment:       0,
-		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xEE}, 48)},
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
 		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
 	}
 	signed := &ethpb.SignedExecutionPayloadBid{
@@ -244,7 +244,7 @@ func TestProcessExecutionPayloadBid_SelfBuildNonZeroAmountFails(t *testing.T) {
 		Slot:                   slot,
 		Value:                  10,
 		ExecutionPayment:       0,
-		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xCC}, 48)},
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
 		FeeRecipient:           bytes.Repeat([]byte{0xDD}, 20),
 	}
 	signed := &ethpb.SignedExecutionPayloadBid{
@@ -289,7 +289,7 @@ func TestProcessExecutionPayloadBid_PendingPaymentAndCacheBid(t *testing.T) {
 		Slot:                   slot,
 		Value:                  500_000,
 		ExecutionPayment:       1,
-		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xEE}, 48)},
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
 		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
 	}
 
@@ -350,7 +350,7 @@ func TestProcessExecutionPayloadBid_BuilderNotActive(t *testing.T) {
 		Slot:                   slot,
 		Value:                  10,
 		ExecutionPayment:       0,
-		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0x05}, 48)},
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x05}, 32),
 		FeeRecipient:           bytes.Repeat([]byte{0x06}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
@@ -403,7 +403,7 @@ func TestProcessExecutionPayloadBid_CannotCoverBid(t *testing.T) {
 		Slot:                   slot,
 		Value:                  25,
 		ExecutionPayment:       0,
-		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xEE}, 48)},
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
 		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
@@ -445,7 +445,7 @@ func TestProcessExecutionPayloadBid_InvalidSignature(t *testing.T) {
 		Slot:                   slot,
 		Value:                  10,
 		ExecutionPayment:       0,
-		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xEE}, 48)},
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
 		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
 	}
 	// Use an invalid signature.
@@ -487,7 +487,7 @@ func TestProcessExecutionPayloadBid_SlotMismatch(t *testing.T) {
 		Slot:                   slot + 1, // mismatch
 		Value:                  1,
 		ExecutionPayment:       0,
-		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xCC}, 48)},
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
 		FeeRecipient:           bytes.Repeat([]byte{0xDD}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
@@ -529,7 +529,7 @@ func TestProcessExecutionPayloadBid_ParentHashMismatch(t *testing.T) {
 		Slot:                   slot,
 		Value:                  1,
 		ExecutionPayment:       0,
-		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0x44}, 48)},
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
 		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
@@ -572,7 +572,7 @@ func TestProcessExecutionPayloadBid_ParentRootMismatch(t *testing.T) {
 		Slot:                   slot,
 		Value:                  1,
 		ExecutionPayment:       0,
-		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0x44}, 48)},
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
 		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
@@ -614,7 +614,7 @@ func TestProcessExecutionPayloadBid_PrevRandaoMismatch(t *testing.T) {
 		Slot:                   slot,
 		Value:                  1,
 		ExecutionPayment:       0,
-		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0x44}, 48)},
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
 		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())

beacon-chain/core/gloas/builder.go

@@ -1,17 +0,0 @@
-package gloas
-
-import (
-	"github.com/OffchainLabs/prysm/v7/config/params"
-)
-
-// IsBuilderWithdrawalCredential returns true when the builder withdrawal prefix is set.
-// Spec v1.6.1 (pseudocode):
-// def is_builder_withdrawal_credential(withdrawal_credentials: Bytes32) -> bool:
-//
-//	return withdrawal_credentials[:1] == BUILDER_WITHDRAWAL_PREFIX
-func IsBuilderWithdrawalCredential(withdrawalCredentials []byte) bool {
-	if len(withdrawalCredentials) == 0 {
-		return false
-	}
-	return withdrawalCredentials[0] == params.BeaconConfig().BuilderWithdrawalPrefixByte
-}

beacon-chain/core/gloas/withdrawal.go

@@ -1,117 +0,0 @@
-package gloas
-
-import (
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/pkg/errors"
-)
-
-// ProcessWithdrawals applies withdrawals to the state for Gloas.
-//
-// Spec v1.7.0-alpha.1 (pseudocode):
-//
-// def process_withdrawals(
-//
-//	state: BeaconState,
-//	# [Modified in Gloas:EIP7732]
-//	# Removed `payload`
-//
-// ) -> None:
-//
-//	# [New in Gloas:EIP7732]
-//	# Return early if the parent block is empty
-//	if not is_parent_block_full(state):
-//	    return
-//
-//	# Get expected withdrawals
-//	expected = get_expected_withdrawals(state)
-//
-//	# Apply expected withdrawals
-//	apply_withdrawals(state, expected.withdrawals)
-//
-//	# Update withdrawals fields in the state
-//	update_next_withdrawal_index(state, expected.withdrawals)
-//	# [New in Gloas:EIP7732]
-//	update_payload_expected_withdrawals(state, expected.withdrawals)
-//	# [New in Gloas:EIP7732]
-//	update_builder_pending_withdrawals(state, expected.processed_builder_withdrawals_count)
-//	update_pending_partial_withdrawals(state, expected.processed_partial_withdrawals_count)
-//	# [New in Gloas:EIP7732]
-//	update_next_withdrawal_builder_index(state, expected.processed_builders_sweep_count)
-//	update_next_withdrawal_validator_index(state, expected.withdrawals)
-func ProcessWithdrawals(st state.BeaconState) error {
-	full, err := st.IsParentBlockFull()
-	if err != nil {
-		return errors.Wrap(err, "could not get parent block full status")
-	}
-	if !full {
-		return nil
-	}
-
-	expectedWithdrawals, processedBuilderWithdrawalsCount, processedPartialWithdrawalsCount, nextWithdrawalBuilderIndex, err := st.ExpectedWithdrawalsGloas()
-	if err != nil {
-		return errors.Wrap(err, "could not get expected withdrawals")
-	}
-
-	for _, withdrawal := range expectedWithdrawals {
-		if withdrawal.ValidatorIndex.IsBuilderIndex() {
-			builderIndex := withdrawal.ValidatorIndex.ToBuilderIndex()
-			err := st.DecreaseBuilderBalance(builderIndex, withdrawal.Amount)
-			if err != nil {
-				return errors.Wrap(err, "could not decrease builder balance")
-			}
-		} else {
-			err := helpers.DecreaseBalance(st, withdrawal.ValidatorIndex, withdrawal.Amount)
-			if err != nil {
-				return errors.Wrap(err, "could not decrease balance")
-			}
-		}
-}
-
-	err = st.SetPayloadExpectedWithdrawals(expectedWithdrawals)
-	if err != nil {
-		return errors.Wrap(err, "could not set payload expected withdrawals")
-	}
-	err = st.DequeueBuilderPendingWithdrawals(processedBuilderWithdrawalsCount)
-	if err != nil {
-		return fmt.Errorf("unable to dequeue builder pending withdrawals from state: %w", err)
-	}
-	err = st.SetNextWithdrawalBuilderIndex(nextWithdrawalBuilderIndex)
-	if err != nil {
-		return errors.Wrap(err, "could not set next withdrawal builder index")
-	}
-
-	if err := st.DequeuePendingPartialWithdrawals(processedPartialWithdrawalsCount); err != nil {
-		return fmt.Errorf("unable to dequeue partial withdrawals from state: %w", err)
-	}
-
-	if len(expectedWithdrawals) > 0 {
-		if err := st.SetNextWithdrawalIndex(expectedWithdrawals[len(expectedWithdrawals)-1].Index + 1); err != nil {
-			return errors.Wrap(err, "could not set next withdrawal index")
-		}
-	}
-
-	var nextValidatorIndex primitives.ValidatorIndex
-	if uint64(len(expectedWithdrawals)) < params.BeaconConfig().MaxWithdrawalsPerPayload {
-		nextValidatorIndex, err = st.NextWithdrawalValidatorIndex()
-		if err != nil {
-			return errors.Wrap(err, "could not get next withdrawal validator index")
-		}
-		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
-		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
-	} else {
-		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1
-		if nextValidatorIndex == primitives.ValidatorIndex(st.NumValidators()) {
-			nextValidatorIndex = 0
-		}
-	}
-	if err := st.SetNextWithdrawalValidatorIndex(nextValidatorIndex); err != nil {
-		return errors.Wrap(err, "could not set next withdrawal validator index")
-	}
-
-	return nil
-}

beacon-chain/core/transition/transition_gloas_test.go

@@ -78,7 +78,7 @@ func newGloasState(t *testing.T, slot primitives.Slot, availability []byte) stat
 			BlockHash:              make([]byte, 32),
 			PrevRandao:             make([]byte, 32),
 			FeeRecipient:           make([]byte, 20),
-			BlobKzgCommitments:     [][]byte{make([]byte, 48)},
+			BlobKzgCommitmentsRoot: make([]byte, 32),
 		},
 		Eth1Data: &ethpb.Eth1Data{
 			DepositRoot: make([]byte, 32),

beacon-chain/state/interfaces_gloas.go

@@ -3,7 +3,6 @@ package state
 import (
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 )
 
@@ -14,11 +13,7 @@ type writeOnlyGloasFields interface {
 	RotateBuilderPendingPayments() error
 	AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal) error
 	UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val byte) error
-
-	SetPayloadExpectedWithdrawals(withdrawals []*enginev1.Withdrawal) error
-	DequeueBuilderPendingWithdrawals(num uint64) error
-	SetNextWithdrawalBuilderIndex(idx primitives.BuilderIndex) error
-	DecreaseBuilderBalance(builderIndex primitives.BuilderIndex, amount uint64) error
+	UpdatePendingPaymentWeight(att ethpb.Att, indices []uint64, participatedFlags map[uint8]bool) error
 }
 
 type readOnlyGloasFields interface {
@@ -26,8 +21,8 @@ type readOnlyGloasFields interface {
 	IsActiveBuilder(primitives.BuilderIndex) (bool, error)
 	CanBuilderCoverBid(primitives.BuilderIndex, primitives.Gwei) (bool, error)
 	LatestBlockHash() ([32]byte, error)
+	IsAttestationSameSlot(blockRoot [32]byte, slot primitives.Slot) (bool, error)
+	BuilderPendingPayment(index uint64) (*ethpb.BuilderPendingPayment, error)
 	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
-
-	IsParentBlockFull() (bool, error)
-	ExpectedWithdrawalsGloas() ([]*enginev1.Withdrawal, uint64, uint64, primitives.BuilderIndex, error)
+	ExecutionPayloadAvailability(slot primitives.Slot) (uint64, error)
 }

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

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

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

@@ -4,29 +4,15 @@ import (
 	"bytes"
 	"fmt"
 
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/pkg/errors"
 )
 
-// IsParentBlockFull returns true when the latest bid was fulfilled with a payload.
-func (b *BeaconState) IsParentBlockFull() (bool, error) {
-	if b.version < version.Gloas {
-		return false, errNotSupported("IsParentBlockFull", b.version)	
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.latestExecutionPayloadBid == nil {
-		return false, nil
-	}
-
-	return bytes.Equal(b.latestExecutionPayloadBid.BlockHash, b.latestBlockHash), nil
-}
-
 // LatestBlockHash returns the hash of the latest execution block.
 func (b *BeaconState) LatestBlockHash() ([32]byte, error) {
 	if b.version < version.Gloas {
@@ -43,6 +29,45 @@ func (b *BeaconState) LatestBlockHash() ([32]byte, error) {
 	return [32]byte(b.latestBlockHash), nil
 }
 
+// IsAttestationSameSlot checks if the attestation is for the same slot as the block root in the state.
+// Spec v1.7.0-alpha pseudocode:
+//
+//	is_attestation_same_slot(state, data):
+//	    if data.slot == 0:
+//	        return True
+//
+//	    blockroot = data.beacon_block_root
+//	    slot_blockroot = get_block_root_at_slot(state, data.slot)
+//	    prev_blockroot = get_block_root_at_slot(state, Slot(data.slot - 1))
+//
+//	    return blockroot == slot_blockroot and blockroot != prev_blockroot
+func (b *BeaconState) IsAttestationSameSlot(blockRoot [32]byte, slot primitives.Slot) (bool, error) {
+	if b.version < version.Gloas {
+		return false, errNotSupported("IsAttestationSameSlot", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	if slot == 0 {
+		return true, nil
+	}
+
+	blockRootAtSlot, err := helpers.BlockRootAtSlot(b, slot)
+	if err != nil {
+		return false, errors.Wrapf(err, "block root at slot %d", slot)
+	}
+	matchingBlockRoot := bytes.Equal(blockRoot[:], blockRootAtSlot)
+
+	blockRootAtPrevSlot, err := helpers.BlockRootAtSlot(b, slot-1)
+	if err != nil {
+		return false, errors.Wrapf(err, "block root at slot %d", slot-1)
+	}
+	matchingPrevBlockRoot := bytes.Equal(blockRoot[:], blockRootAtPrevSlot)
+
+	return matchingBlockRoot && !matchingPrevBlockRoot, nil
+}
+
 // BuilderPubkey returns the builder pubkey at the provided index.
 func (b *BeaconState) BuilderPubkey(builderIndex primitives.BuilderIndex) ([fieldparams.BLSPubkeyLength]byte, error) {
 	if b.version < version.Gloas {
@@ -165,55 +190,35 @@ func (b *BeaconState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment,
 	return b.builderPendingPaymentsVal(), nil
 }
 
-// BuilderPendingWithdrawals returns the builder pending withdrawals queue.
-func (b *BeaconState) BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error) {
+// BuilderPendingPayment returns the builder pending payment for the given index.
+func (b *BeaconState) BuilderPendingPayment(index uint64) (*ethpb.BuilderPendingPayment, error) {
 	if b.version < version.Gloas {
-		return nil, errNotSupported("BuilderPendingWithdrawals", b.version)
+		return nil, errNotSupported("BuilderPendingPayment", b.version)
 	}
 
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	return b.builderPendingWithdrawalsVal(), nil
+	if index >= uint64(len(b.builderPendingPayments)) {
+		return nil, fmt.Errorf("builder pending payment index %d out of range (len=%d)", index, len(b.builderPendingPayments))
+	}
+	return ethpb.CopyBuilderPendingPayment(b.builderPendingPayments[index]), nil
 }
 
-// BuildersCount returns the number of builders in the registry.
-func (b *BeaconState) BuildersCount() int {
+// ExecutionPayloadAvailability returns the execution payload availability bit for the given slot.
+func (b *BeaconState) ExecutionPayloadAvailability(slot primitives.Slot) (uint64, error) {
 	if b.version < version.Gloas {
-		return 0
+		return 0, errNotSupported("ExecutionPayloadAvailability", b.version)
 	}
 
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	return len(b.builders)
-}
-
-// Builders returns the builders registry.
-func (b *BeaconState) Builders() ([]*ethpb.Builder, error) {
-	if b.version < version.Gloas {
-		return nil, errNotSupported("Builders", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	builders := make([]*ethpb.Builder, len(b.builders))
-	for i := range b.builders {
-		builders[i] = ethpb.CopyBuilder(b.builders[i])
-	}
-
-	return builders, nil
-}
-
-// NextWithdrawalBuilderIndex returns the next builder index for the withdrawals sweep.
-func (b *BeaconState) NextWithdrawalBuilderIndex() (primitives.BuilderIndex, error) {
-	if b.version < version.Gloas {
-		return 0, errNotSupported("NextWithdrawalBuilderIndex", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return b.nextWithdrawalBuilderIndex, nil
+	slotIndex := slot % params.BeaconConfig().SlotsPerHistoricalRoot
+	byteIndex := slotIndex / 8
+	bitIndex := slotIndex % 8
+
+	bit := (b.executionPayloadAvailability[byteIndex] >> bitIndex) & 1
+
+	return uint64(bit), nil
 }

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

@@ -44,54 +44,90 @@ func TestLatestBlockHash(t *testing.T) {
 	})
 }
 
-func TestIsParentBlockFull(t *testing.T) {
-	t.Run("returns error before gloas", func(t *testing.T) {
-		st, _ := util.DeterministicGenesisState(t, 1)
-		_, err := st.IsParentBlockFull()
-		require.ErrorContains(t, "is not supported", err)
-	})
+func TestIsAttestationSameSlot(t *testing.T) {
+	buildStateWithBlockRoots := func(t *testing.T, stateSlot primitives.Slot, roots map[primitives.Slot][]byte) *state_native.BeaconState {
+		t.Helper()
 
-	t.Run("returns false when bid is unset", func(t *testing.T) {
-		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			LatestBlockHash: bytes.Repeat([]byte{0xAB}, 32),
+		cfg := params.BeaconConfig()
+		blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+		for slot, root := range roots {
+			blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
+		}
+
+		stIface, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Slot:       stateSlot,
+			BlockRoots: blockRoots,
 		})
 		require.NoError(t, err)
+		return stIface.(*state_native.BeaconState)
+	}
 
-		full, err := st.IsParentBlockFull()
-		require.NoError(t, err)
-		require.Equal(t, false, full)
-	})
+	rootA := bytes.Repeat([]byte{0xAA}, 32)
+	rootB := bytes.Repeat([]byte{0xBB}, 32)
+	rootC := bytes.Repeat([]byte{0xCC}, 32)
 
-	t.Run("returns true when bid block hash matches latest block hash", func(t *testing.T) {
-		hashBytes := bytes.Repeat([]byte{0xAB}, 32)
-		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			LatestBlockHash: hashBytes,
-			LatestExecutionPayloadBid: &ethpb.ExecutionPayloadBid{
-				BlockHash: hashBytes,
+	tests := []struct {
+		name      string
+		stateSlot primitives.Slot
+		slot      primitives.Slot
+		blockRoot []byte
+		roots     map[primitives.Slot][]byte
+		want      bool
+	}{
+		{
+			name:      "slot zero always true",
+			stateSlot: 1,
+			slot:      0,
+			blockRoot: rootA,
+			roots:     map[primitives.Slot][]byte{},
+			want:      true,
+		},
+		{
+			name:      "matching current different previous",
+			stateSlot: 6,
+			slot:      4,
+			blockRoot: rootA,
+			roots: map[primitives.Slot][]byte{
+				4: rootA,
+				3: rootB,
 			},
-		})
-		require.NoError(t, err)
-
-		full, err := st.IsParentBlockFull()
-		require.NoError(t, err)
-		require.Equal(t, true, full)
-	})
-
-	t.Run("returns false when bid block hash does not match latest block hash", func(t *testing.T) {
-		latest := bytes.Repeat([]byte{0xAB}, 32)
-		bid := bytes.Repeat([]byte{0xCD}, 32)
-		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			LatestBlockHash: latest,
-			LatestExecutionPayloadBid: &ethpb.ExecutionPayloadBid{
-				BlockHash: bid,
+			want: true,
+		},
+		{
+			name:      "matching current same previous",
+			stateSlot: 6,
+			slot:      4,
+			blockRoot: rootA,
+			roots: map[primitives.Slot][]byte{
+				4: rootA,
+				3: rootA,
 			},
-		})
-		require.NoError(t, err)
+			want: false,
+		},
+		{
+			name:      "non matching current",
+			stateSlot: 6,
+			slot:      4,
+			blockRoot: rootC,
+			roots: map[primitives.Slot][]byte{
+				4: rootA,
+				3: rootB,
+			},
+			want: false,
+		},
+	}
 
-		full, err := st.IsParentBlockFull()
-		require.NoError(t, err)
-		require.Equal(t, false, full)
-	})
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			st := buildStateWithBlockRoots(t, tt.stateSlot, tt.roots)
+			var rootArr [32]byte
+			copy(rootArr[:], tt.blockRoot)
+
+			got, err := st.IsAttestationSameSlot(rootArr, tt.slot)
+			require.NoError(t, err)
+			require.Equal(t, tt.want, got)
+		})
+	}
 }
 
 func TestBuilderPubkey(t *testing.T) {
@@ -216,3 +252,79 @@ func TestBuilderPendingPayments_UnsupportedVersion(t *testing.T) {
 	_, err = st.BuilderPendingPayments()
 	require.ErrorContains(t, "BuilderPendingPayments", err)
 }
+
+func TestBuilderPendingPayment(t *testing.T) {
+	t.Run("returns copy", func(t *testing.T) {
+		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+		payments := make([]*ethpb.BuilderPendingPayment, 2*slotsPerEpoch)
+		target := uint64(slotsPerEpoch + 1)
+		payments[target] = &ethpb.BuilderPendingPayment{Weight: 10}
+
+		st, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
+			BuilderPendingPayments: payments,
+		})
+		require.NoError(t, err)
+
+		payment, err := st.BuilderPendingPayment(target)
+		require.NoError(t, err)
+
+		// mutate returned copy
+		payment.Weight = 99
+
+		original, err := st.BuilderPendingPayment(target)
+		require.NoError(t, err)
+		require.Equal(t, uint64(10), uint64(original.Weight))
+	})
+
+	t.Run("unsupported version", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.BuilderPendingPayment(0)
+		require.ErrorContains(t, "BuilderPendingPayment", err)
+	})
+
+	t.Run("out of range", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
+			BuilderPendingPayments: []*ethpb.BuilderPendingPayment{},
+		})
+		require.NoError(t, err)
+
+		_, err = stIface.BuilderPendingPayment(0)
+		require.ErrorContains(t, "out of range", err)
+	})
+}
+
+func TestExecutionPayloadAvailability(t *testing.T) {
+	t.Run("unsupported version", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.ExecutionPayloadAvailability(0)
+		require.ErrorContains(t, "ExecutionPayloadAvailability", err)
+	})
+
+	t.Run("reads expected bit", func(t *testing.T) {
+		// Ensure the backing slice is large enough.
+		availability := make([]byte, params.BeaconConfig().SlotsPerHistoricalRoot/8)
+
+		// Pick a slot and set its corresponding bit.
+		slot := primitives.Slot(9) // byteIndex=1, bitIndex=1
+		availability[1] = 0b00000010
+
+		stIface, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
+			ExecutionPayloadAvailability: availability,
+		})
+		require.NoError(t, err)
+
+		bit, err := stIface.ExecutionPayloadAvailability(slot)
+		require.NoError(t, err)
+		require.Equal(t, uint64(1), bit)
+
+		otherBit, err := stIface.ExecutionPayloadAvailability(8)
+		require.NoError(t, err)
+		require.Equal(t, uint64(0), otherBit)
+	})
+}

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

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

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

@@ -113,111 +113,77 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, uint64, err
 	defer b.lock.RUnlock()
 
 	withdrawals := make([]*enginev1.Withdrawal, 0, params.BeaconConfig().MaxWithdrawalsPerPayload)
-	withdrawalIndex := b.nextWithdrawalIndex
-
-	withdrawalIndex, processedPartialWithdrawalsCount, err := b.appendPendingPartialWithdrawals(withdrawalIndex, &withdrawals)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	err = b.appendValidatorsSweepWithdrawals(withdrawalIndex, &withdrawals)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	return withdrawals, processedPartialWithdrawalsCount, nil
-}
-
-func (b *BeaconState) appendPendingPartialWithdrawals(withdrawalIndex uint64, withdrawals *[]*enginev1.Withdrawal) (uint64, uint64, error) {
-	if b.version < version.Electra {
-		return withdrawalIndex, 0, nil
-	}
-
-	cfg := params.BeaconConfig()
-	withdrawalsLimit := min(
-		uint64(len(*withdrawals))+cfg.MaxPendingPartialsPerWithdrawalsSweep,
-		cfg.MaxWithdrawalsPerPayload-1,
-	)
-	if uint64(len(*withdrawals)) > withdrawalsLimit {
-		return withdrawalIndex, 0, fmt.Errorf("prior withdrawals length %d exceeds limit %d", len(*withdrawals), withdrawalsLimit)
-	}
-
-	ws := *withdrawals
-	epoch := slots.ToEpoch(b.slot)
-	var processedPartialWithdrawalsCount uint64
-	for _, w := range b.pendingPartialWithdrawals {
-		isWithdrawable := w.WithdrawableEpoch <= epoch
-		hasReachedLimit := uint64(len(ws)) >= withdrawalsLimit
-		if !isWithdrawable || hasReachedLimit {
-			break
-		}
-
-		v, err := b.validatorAtIndexReadOnly(w.Index)
-		if err != nil {
-			return withdrawalIndex, 0, fmt.Errorf("failed to determine withdrawals at index %d: %w", w.Index, err)
-		}
-		vBal, err := b.balanceAtIndex(w.Index)
-		if err != nil {
-			return withdrawalIndex, 0, fmt.Errorf("could not retrieve balance at index %d: %w", w.Index, err)
-		}
-		hasSufficientEffectiveBalance := v.EffectiveBalance() >= cfg.MinActivationBalance
-		var totalWithdrawn uint64
-		for _, wi := range ws {
-			if wi.ValidatorIndex == w.Index {
-				totalWithdrawn += wi.Amount
-			}
-		}
-		balance, err := mathutil.Sub64(vBal, totalWithdrawn)
-		if err != nil {
-			return withdrawalIndex, 0, errors.Wrapf(err, "failed to subtract balance %d with total withdrawn %d", vBal, totalWithdrawn)
-		}
-		hasExcessBalance := balance > cfg.MinActivationBalance
-		if v.ExitEpoch() == cfg.FarFutureEpoch && hasSufficientEffectiveBalance && hasExcessBalance {
-			amount := min(balance-cfg.MinActivationBalance, w.Amount)
-			ws = append(ws, &enginev1.Withdrawal{
-				Index:          withdrawalIndex,
-				ValidatorIndex: w.Index,
-				Address:        v.GetWithdrawalCredentials()[12:],
-				Amount:         amount,
-			})
-			withdrawalIndex++
-		}
-		processedPartialWithdrawalsCount++
-	}
-
-	*withdrawals = ws
-	return withdrawalIndex, processedPartialWithdrawalsCount, nil
-}
-
-func (b *BeaconState) appendValidatorsSweepWithdrawals(withdrawalIndex uint64, withdrawals *[]*enginev1.Withdrawal) error {
-	ws := *withdrawals
 	validatorIndex := b.nextWithdrawalValidatorIndex
-	validatorsLen := b.validatorsLen()
+	withdrawalIndex := b.nextWithdrawalIndex
 	epoch := slots.ToEpoch(b.slot)
+
+	// Electra partial withdrawals functionality.
+	var processedPartialWithdrawalsCount uint64
+	if b.version >= version.Electra {
+		for _, w := range b.pendingPartialWithdrawals {
+			if w.WithdrawableEpoch > epoch || len(withdrawals) >= int(params.BeaconConfig().MaxPendingPartialsPerWithdrawalsSweep) {
+				break
+			}
+
+			v, err := b.validatorAtIndexReadOnly(w.Index)
+			if err != nil {
+				return nil, 0, fmt.Errorf("failed to determine withdrawals at index %d: %w", w.Index, err)
+			}
+			vBal, err := b.balanceAtIndex(w.Index)
+			if err != nil {
+				return nil, 0, fmt.Errorf("could not retrieve balance at index %d: %w", w.Index, err)
+			}
+			hasSufficientEffectiveBalance := v.EffectiveBalance() >= params.BeaconConfig().MinActivationBalance
+			var totalWithdrawn uint64
+			for _, wi := range withdrawals {
+				if wi.ValidatorIndex == w.Index {
+					totalWithdrawn += wi.Amount
+				}
+			}
+			balance, err := mathutil.Sub64(vBal, totalWithdrawn)
+			if err != nil {
+				return nil, 0, errors.Wrapf(err, "failed to subtract balance %d with total withdrawn %d", vBal, totalWithdrawn)
+			}
+			hasExcessBalance := balance > params.BeaconConfig().MinActivationBalance
+			if v.ExitEpoch() == params.BeaconConfig().FarFutureEpoch && hasSufficientEffectiveBalance && hasExcessBalance {
+				amount := min(balance-params.BeaconConfig().MinActivationBalance, w.Amount)
+				withdrawals = append(withdrawals, &enginev1.Withdrawal{
+					Index:          withdrawalIndex,
+					ValidatorIndex: w.Index,
+					Address:        v.GetWithdrawalCredentials()[12:],
+					Amount:         amount,
+				})
+				withdrawalIndex++
+			}
+			processedPartialWithdrawalsCount++
+		}
+	}
+
+	validatorsLen := b.validatorsLen()
 	bound := min(uint64(validatorsLen), params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
 	for range bound {
 		val, err := b.validatorAtIndexReadOnly(validatorIndex)
 		if err != nil {
-			return errors.Wrapf(err, "could not retrieve validator at index %d", validatorIndex)
+			return nil, 0, errors.Wrapf(err, "could not retrieve validator at index %d", validatorIndex)
 		}
 		balance, err := b.balanceAtIndex(validatorIndex)
 		if err != nil {
-			return errors.Wrapf(err, "could not retrieve balance at index %d", validatorIndex)
+			return nil, 0, errors.Wrapf(err, "could not retrieve balance at index %d", validatorIndex)
 		}
 		if b.version >= version.Electra {
 			var partiallyWithdrawnBalance uint64
-			for _, w := range ws {
+			for _, w := range withdrawals {
 				if w.ValidatorIndex == validatorIndex {
 					partiallyWithdrawnBalance += w.Amount
 				}
 			}
 			balance, err = mathutil.Sub64(balance, partiallyWithdrawnBalance)
 			if err != nil {
-				return errors.Wrapf(err, "could not subtract balance %d with partial withdrawn balance %d", balance, partiallyWithdrawnBalance)
+				return nil, 0, errors.Wrapf(err, "could not subtract balance %d with partial withdrawn balance %d", balance, partiallyWithdrawnBalance)
 			}
 		}
 		if helpers.IsFullyWithdrawableValidator(val, balance, epoch, b.version) {
-			ws = append(ws, &enginev1.Withdrawal{
+			withdrawals = append(withdrawals, &enginev1.Withdrawal{
 				Index:          withdrawalIndex,
 				ValidatorIndex: validatorIndex,
 				Address:        bytesutil.SafeCopyBytes(val.GetWithdrawalCredentials()[ETH1AddressOffset:]),
@@ -225,7 +191,7 @@ func (b *BeaconState) appendValidatorsSweepWithdrawals(withdrawalIndex uint64, w
 			})
 			withdrawalIndex++
 		} else if helpers.IsPartiallyWithdrawableValidator(val, balance, epoch, b.version) {
-			ws = append(ws, &enginev1.Withdrawal{
+			withdrawals = append(withdrawals, &enginev1.Withdrawal{
 				Index:          withdrawalIndex,
 				ValidatorIndex: validatorIndex,
 				Address:        bytesutil.SafeCopyBytes(val.GetWithdrawalCredentials()[ETH1AddressOffset:]),
@@ -233,7 +199,7 @@ func (b *BeaconState) appendValidatorsSweepWithdrawals(withdrawalIndex uint64, w
 			})
 			withdrawalIndex++
 		}
-		if uint64(len(ws)) == params.BeaconConfig().MaxWithdrawalsPerPayload {
+		if uint64(len(withdrawals)) == params.BeaconConfig().MaxWithdrawalsPerPayload {
 			break
 		}
 		validatorIndex += 1
@@ -242,8 +208,7 @@ func (b *BeaconState) appendValidatorsSweepWithdrawals(withdrawalIndex uint64, w
 		}
 	}
 
-	*withdrawals = ws
-	return nil
+	return withdrawals, processedPartialWithdrawalsCount, nil
 }
 
 func (b *BeaconState) PendingPartialWithdrawals() ([]*ethpb.PendingPartialWithdrawal, error) {

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

@@ -1,7 +1,6 @@
 package state_native
 
 import (
-	"errors"
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
@@ -9,27 +8,11 @@ import (
 	"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"
-	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/OffchainLabs/prysm/v7/time/slots"
 )
 
-// SetPayloadExpectedWithdrawals stores the expected withdrawals for the next payload.
-func (b *BeaconState) SetPayloadExpectedWithdrawals(withdrawals []*enginev1.Withdrawal) error {
-	if b.version < version.Gloas {
-		return errNotSupported("SetPayloadExpectedWithdrawals", b.version)
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.payloadExpectedWithdrawals = withdrawals
-	b.markFieldAsDirty(types.PayloadExpectedWithdrawals)
-
-	return nil
-}
-
 // RotateBuilderPendingPayments rotates the queue by dropping slots per epoch payments from the
 // front and appending slots per epoch empty payments to the end.
 // This implements: state.builder_pending_payments = state.builder_pending_payments[SLOTS_PER_EPOCH:] + [BuilderPendingPayment() for _ in range(SLOTS_PER_EPOCH)]
@@ -87,38 +70,6 @@ func (b *BeaconState) AppendBuilderPendingWithdrawals(withdrawals []*ethpb.Build
 	return nil
 }
 
-// DequeueBuilderPendingWithdrawals removes processed builder withdrawals from the front of the queue.
-func (b *BeaconState) DequeueBuilderPendingWithdrawals(n uint64) error {
-	if b.version < version.Gloas {
-		return errNotSupported("DequeueBuilderPendingWithdrawals", b.version)
-	}
-
-	if n > uint64(len(b.builderPendingWithdrawals)) {
-		return errors.New("cannot dequeue more builder withdrawals than are in the queue")
-	}
-
-	if n == 0 {
-		return nil
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if b.sharedFieldReferences[types.BuilderPendingWithdrawals].Refs() > 1 {
-		withdrawals := make([]*ethpb.BuilderPendingWithdrawal, len(b.builderPendingWithdrawals))
-		copy(withdrawals, b.builderPendingWithdrawals)
-		b.builderPendingWithdrawals = withdrawals
-		b.sharedFieldReferences[types.BuilderPendingWithdrawals].MinusRef()
-		b.sharedFieldReferences[types.BuilderPendingWithdrawals] = stateutil.NewRef(1)
-	}
-
-	b.builderPendingWithdrawals = b.builderPendingWithdrawals[n:]
-	b.markFieldAsDirty(types.BuilderPendingWithdrawals)
-	b.rebuildTrie[types.BuilderPendingWithdrawals] = true
-
-	return nil
-}
-
 // SetExecutionPayloadBid sets the latest execution payload bid in the state.
 func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error {
 	if b.version < version.Gloas {
@@ -132,7 +83,7 @@ func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid)
 	parentBlockRoot := h.ParentBlockRoot()
 	blockHash := h.BlockHash()
 	randao := h.PrevRandao()
-	blobKzgCommitments := bytesutil.SafeCopy2dBytes(h.BlobKzgCommitments())
+	blobKzgCommitmentsRoot := h.BlobKzgCommitmentsRoot()
 	feeRecipient := h.FeeRecipient()
 	b.latestExecutionPayloadBid = &ethpb.ExecutionPayloadBid{
 		ParentBlockHash:        parentBlockHash[:],
@@ -144,7 +95,7 @@ func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid)
 		Slot:                   h.Slot(),
 		Value:                  h.Value(),
 		ExecutionPayment:       h.ExecutionPayment(),
-		BlobKzgCommitments:     blobKzgCommitments,
+		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot[:],
 		FeeRecipient:           feeRecipient[:],
 	}
 	b.markFieldAsDirty(types.LatestExecutionPayloadBid)
@@ -212,64 +163,122 @@ func (b *BeaconState) UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val
 	return nil
 }
 
-// SetNextWithdrawalBuilderIndex sets the next builder index for the withdrawals sweep.
-func (b *BeaconState) SetNextWithdrawalBuilderIndex(index primitives.BuilderIndex) error {
-	if b.version < version.Gloas {
-		return errNotSupported("SetNextWithdrawalBuilderIndex", b.version)
+// UpdatePendingPaymentWeight updates the builder pending payment weight based on attestation participation.
+//
+// This is a no-op for pre-Gloas forks.
+//
+// Spec v1.7.0-alpha pseudocode:
+//
+//	if data.target.epoch == get_current_epoch(state):
+//	    current_epoch_target = True
+//	    epoch_participation = state.current_epoch_participation
+//	    payment = state.builder_pending_payments[SLOTS_PER_EPOCH + data.slot % SLOTS_PER_EPOCH]
+//	else:
+//	    current_epoch_target = False
+//	    epoch_participation = state.previous_epoch_participation
+//	    payment = state.builder_pending_payments[data.slot % SLOTS_PER_EPOCH]
+//
+//	proposer_reward_numerator = 0
+//	for index in get_attesting_indices(state, attestation):
+//	    will_set_new_flag = False
+//	    for flag_index, weight in enumerate(PARTICIPATION_FLAG_WEIGHTS):
+//	        if flag_index in participation_flag_indices and not has_flag(epoch_participation[index], flag_index):
+//	            epoch_participation[index] = add_flag(epoch_participation[index], flag_index)
+//	            proposer_reward_numerator += get_base_reward(state, index) * weight
+//	            # [New in Gloas:EIP7732]
+//	            will_set_new_flag = True
+//	    if (
+//	        will_set_new_flag
+//	        and is_attestation_same_slot(state, data)
+//	        and payment.withdrawal.amount > 0
+//	    ):
+//	        payment.weight += state.validators[index].effective_balance
+//	if current_epoch_target:
+//	    state.builder_pending_payments[SLOTS_PER_EPOCH + data.slot % SLOTS_PER_EPOCH] = payment
+//	else:
+//	    state.builder_pending_payments[data.slot % SLOTS_PER_EPOCH] = payment
+func (b *BeaconState) UpdatePendingPaymentWeight(att ethpb.Att, indices []uint64, participatedFlags map[uint8]bool) error {
+	var (
+		paymentSlot    primitives.Slot
+		currentPayment *ethpb.BuilderPendingPayment
+		weight         primitives.Gwei
+	)
+
+	early, err := func() (bool, error) {
+		b.lock.RLock()
+		defer b.lock.RUnlock()
+
+		if b.version < version.Gloas {
+			return true, nil
+		}
+
+		data := att.GetData()
+		var beaconBlockRoot [32]byte
+		copy(beaconBlockRoot[:], data.BeaconBlockRoot)
+		sameSlot, err := b.IsAttestationSameSlot(beaconBlockRoot, data.Slot)
+		if err != nil {
+			return false, err
+		}
+		if !sameSlot {
+			return true, nil
+		}
+
+		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+		var epochParticipation []byte
+
+		if data.Target != nil && data.Target.Epoch == slots.ToEpoch(b.slot) {
+			paymentSlot = slotsPerEpoch + (data.Slot % slotsPerEpoch)
+			epochParticipation = b.currentEpochParticipation
+		} else {
+			paymentSlot = data.Slot % slotsPerEpoch
+			epochParticipation = b.previousEpochParticipation
+		}
+
+		if uint64(paymentSlot) >= uint64(len(b.builderPendingPayments)) {
+			return false, fmt.Errorf("builder pending payments index %d out of range (len=%d)", paymentSlot, len(b.builderPendingPayments))
+		}
+		currentPayment = b.builderPendingPayments[paymentSlot]
+		if currentPayment.Withdrawal.Amount == 0 {
+			return true, nil
+		}
+
+		cfg := params.BeaconConfig()
+		flagIndices := []uint8{cfg.TimelySourceFlagIndex, cfg.TimelyTargetFlagIndex, cfg.TimelyHeadFlagIndex}
+		for _, idx := range indices {
+			if idx >= uint64(len(epochParticipation)) {
+				return false, fmt.Errorf("index %d exceeds participation length %d", idx, len(epochParticipation))
+			}
+			participation := epochParticipation[idx]
+			for _, f := range flagIndices {
+				if !participatedFlags[f] {
+					continue
+				}
+				if participation&(1<<f) == 0 {
+					v, err := b.validatorAtIndexReadOnly(primitives.ValidatorIndex(idx))
+					if err != nil {
+						return false, fmt.Errorf("validator at index %d: %w", idx, err)
+					}
+					weight += primitives.Gwei(v.EffectiveBalance())
+					break
+				}
+			}
+		}
+		return false, nil
+	}()
+	if err != nil {
+		return err
 	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.nextWithdrawalBuilderIndex = index
-	b.markFieldAsDirty(types.NextWithdrawalBuilderIndex)
-	return nil
-}
-
-// DecreaseBuilderBalance decreases the builder's balance by amount (saturating at 0).
-func (b *BeaconState) DecreaseBuilderBalance(builderIndex primitives.BuilderIndex, amount uint64) error {
-	if b.version < version.Gloas {
-		return errNotSupported("DecreaseBuilderBalance", b.version)
-	}
-	if amount == 0 {
+	if early || weight == 0 {
 		return nil
 	}
 
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
-	idx := uint64(builderIndex)
-	if idx >= uint64(len(b.builders)) {
-		return fmt.Errorf("builder index %d out of range (len=%d)", builderIndex, len(b.builders))
-	}
+	newPayment := ethpb.CopyBuilderPendingPayment(currentPayment)
+	newPayment.Weight += weight
+	b.builderPendingPayments[paymentSlot] = newPayment
+	b.markFieldAsDirty(types.BuilderPendingPayments)
 
-	// Copy-on-write for shared builders registry.
-	if b.sharedFieldReferences[types.Builders].Refs() > 1 {
-		builders := make([]*ethpb.Builder, len(b.builders))
-		copy(builders, b.builders)
-		b.builders = builders
-		b.sharedFieldReferences[types.Builders].MinusRef()
-		b.sharedFieldReferences[types.Builders] = stateutil.NewRef(1)
-
-		// Ensure we don't mutate a shared builder pointer.
-		if b.builders[idx] != nil {
-			b.builders[idx] = ethpb.CopyBuilder(b.builders[idx])
-		}
-	}
-
-	builder := b.builders[idx]
-	if builder == nil {
-		return fmt.Errorf("builder at index %d is nil", builderIndex)
-	}
-
-	bal := uint64(builder.Balance)
-	if amount >= bal {
-		builder.Balance = 0
-	} else {
-		builder.Balance = primitives.Gwei(bal - amount)
-	}
-
-	b.markFieldAsDirty(types.Builders)
-	b.addDirtyIndices(types.Builders, []uint64{idx})
 	return nil
 }

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

@@ -8,10 +8,10 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stateutil"
 	"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/runtime/version"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
 )
 
 type testExecutionPayloadBid struct {
@@ -19,7 +19,7 @@ type testExecutionPayloadBid struct {
 	parentBlockRoot        [32]byte
 	blockHash              [32]byte
 	prevRandao             [32]byte
-	blobKzgCommitments     [][]byte
+	blobKzgCommitmentsRoot [32]byte
 	feeRecipient           [20]byte
 	gasLimit               uint64
 	builderIndex           primitives.BuilderIndex
@@ -41,9 +41,9 @@ func (t testExecutionPayloadBid) Value() primitives.Gwei { return t.value }
 func (t testExecutionPayloadBid) ExecutionPayment() primitives.Gwei {
 	return t.executionPayment
 }
-func (t testExecutionPayloadBid) BlobKzgCommitments() [][]byte { return t.blobKzgCommitments }
-func (t testExecutionPayloadBid) FeeRecipient() [20]byte       { return t.feeRecipient }
-func (t testExecutionPayloadBid) IsNil() bool                  { return false }
+func (t testExecutionPayloadBid) BlobKzgCommitmentsRoot() [32]byte { return t.blobKzgCommitmentsRoot }
+func (t testExecutionPayloadBid) FeeRecipient() [20]byte           { return t.feeRecipient }
+func (t testExecutionPayloadBid) IsNil() bool                      { return false }
 
 func TestSetExecutionPayloadBid(t *testing.T) {
 	t.Run("previous fork returns expected error", func(t *testing.T) {
@@ -58,7 +58,7 @@ func TestSetExecutionPayloadBid(t *testing.T) {
 			parentBlockRoot = [32]byte(bytes.Repeat([]byte{0xCD}, 32))
 			blockHash       = [32]byte(bytes.Repeat([]byte{0xEF}, 32))
 			prevRandao      = [32]byte(bytes.Repeat([]byte{0x11}, 32))
-			blobCommitments = [][]byte{bytes.Repeat([]byte{0x22}, 48)}
+			blobRoot        = [32]byte(bytes.Repeat([]byte{0x22}, 32))
 			feeRecipient    [20]byte
 		)
 		copy(feeRecipient[:], bytes.Repeat([]byte{0x33}, len(feeRecipient)))
@@ -71,7 +71,7 @@ func TestSetExecutionPayloadBid(t *testing.T) {
 			parentBlockRoot:        parentBlockRoot,
 			blockHash:              blockHash,
 			prevRandao:             prevRandao,
-			blobKzgCommitments:     blobCommitments,
+			blobKzgCommitmentsRoot: blobRoot,
 			feeRecipient:           feeRecipient,
 			gasLimit:               123,
 			builderIndex:           7,
@@ -87,7 +87,7 @@ func TestSetExecutionPayloadBid(t *testing.T) {
 		require.DeepEqual(t, parentBlockRoot[:], st.latestExecutionPayloadBid.ParentBlockRoot)
 		require.DeepEqual(t, blockHash[:], st.latestExecutionPayloadBid.BlockHash)
 		require.DeepEqual(t, prevRandao[:], st.latestExecutionPayloadBid.PrevRandao)
-		require.DeepEqual(t, blobCommitments, st.latestExecutionPayloadBid.BlobKzgCommitments)
+		require.DeepEqual(t, blobRoot[:], st.latestExecutionPayloadBid.BlobKzgCommitmentsRoot)
 		require.DeepEqual(t, feeRecipient[:], st.latestExecutionPayloadBid.FeeRecipient)
 		require.Equal(t, uint64(123), st.latestExecutionPayloadBid.GasLimit)
 		require.Equal(t, primitives.BuilderIndex(7), st.latestExecutionPayloadBid.BuilderIndex)
@@ -182,6 +182,99 @@ func TestClearBuilderPendingPayment(t *testing.T) {
 	})
 }
 
+func TestUpdatePendingPaymentWeight(t *testing.T) {
+	cfg := params.BeaconConfig()
+	slotsPerEpoch := cfg.SlotsPerEpoch
+	slot := primitives.Slot(4)
+	stateSlot := slot + 1
+	stateEpoch := slots.ToEpoch(stateSlot)
+
+	rootA := bytes.Repeat([]byte{0xAA}, 32)
+	rootB := bytes.Repeat([]byte{0xBB}, 32)
+
+	tests := []struct {
+		name          string
+		targetEpoch   primitives.Epoch
+		blockRoot     []byte
+		initialAmount primitives.Gwei
+		initialWeight primitives.Gwei
+		wantWeight    primitives.Gwei
+	}{
+		{
+			name:          "same slot current epoch adds weight",
+			targetEpoch:   stateEpoch,
+			blockRoot:     rootA,
+			initialAmount: 1,
+			initialWeight: 0,
+			wantWeight:    primitives.Gwei(cfg.MinActivationBalance),
+		},
+		{
+			name:          "same slot zero amount no weight change",
+			targetEpoch:   stateEpoch,
+			blockRoot:     rootA,
+			initialAmount: 0,
+			initialWeight: 5,
+			wantWeight:    5,
+		},
+		{
+			name:          "non matching block root no change",
+			targetEpoch:   stateEpoch,
+			blockRoot:     rootB,
+			initialAmount: 1,
+			initialWeight: 7,
+			wantWeight:    7,
+		},
+		{
+			name:          "previous epoch target uses earlier slot",
+			targetEpoch:   stateEpoch - 1,
+			blockRoot:     rootA,
+			initialAmount: 1,
+			initialWeight: 0,
+			wantWeight:    primitives.Gwei(cfg.MinActivationBalance),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var paymentIdx int
+			if tt.targetEpoch == stateEpoch {
+				paymentIdx = int(slotsPerEpoch + (slot % slotsPerEpoch))
+			} else {
+				paymentIdx = int(slot % slotsPerEpoch)
+			}
+			state := buildGloasStateForPaymentWeightTest(t, stateSlot, paymentIdx, tt.initialAmount, tt.initialWeight, map[primitives.Slot][]byte{
+				slot:     tt.blockRoot,
+				slot - 1: rootB,
+			})
+
+			att := &ethpb.Attestation{
+				Data: &ethpb.AttestationData{
+					Slot:            slot,
+					CommitteeIndex:  0,
+					BeaconBlockRoot: tt.blockRoot,
+					Source:          &ethpb.Checkpoint{},
+					Target: &ethpb.Checkpoint{
+						Epoch: tt.targetEpoch,
+					},
+				},
+			}
+
+			participatedFlags := map[uint8]bool{
+				cfg.TimelySourceFlagIndex: true,
+				cfg.TimelyTargetFlagIndex: true,
+				cfg.TimelyHeadFlagIndex:   true,
+			}
+			indices := []uint64{0}
+
+			require.NoError(t, state.UpdatePendingPaymentWeight(att, indices, participatedFlags))
+
+			payment, err := state.BuilderPendingPayment(uint64(paymentIdx))
+			require.NoError(t, err)
+			require.Equal(t, tt.wantWeight, payment.Weight)
+		})
+	}
+}
+
 func TestRotateBuilderPendingPayments(t *testing.T) {
 	totalPayments := 2 * params.BeaconConfig().SlotsPerEpoch
 	payments := make([]*ethpb.BuilderPendingPayment, totalPayments)
@@ -230,163 +323,6 @@ func TestRotateBuilderPendingPayments_UnsupportedVersion(t *testing.T) {
 	require.ErrorContains(t, "RotateBuilderPendingPayments", err)
 }
 
-func TestSetPayloadExpectedWithdrawals(t *testing.T) {
-	t.Run("previous fork returns expected error", func(t *testing.T) {
-		st := &BeaconState{version: version.Fulu}
-		err := st.SetPayloadExpectedWithdrawals([]*enginev1.Withdrawal{})
-		require.ErrorContains(t, "SetPayloadExpectedWithdrawals", err)
-	})
-
-	t.Run("rejects nil input", func(t *testing.T) {
-		st := &BeaconState{
-			version:     version.Gloas,
-			dirtyFields: make(map[types.FieldIndex]bool),
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.PayloadExpectedWithdrawals: stateutil.NewRef(1),
-			},
-		}
-
-		err := st.SetPayloadExpectedWithdrawals(nil)
-		require.ErrorContains(t, "cannot set nil payload expected withdrawals", err)
-		require.Equal(t, false, st.dirtyFields[types.PayloadExpectedWithdrawals])
-	})
-
-	t.Run("sets and marks dirty", func(t *testing.T) {
-		oldRef := stateutil.NewRef(2)
-		st := &BeaconState{
-			version:     version.Gloas,
-			dirtyFields: make(map[types.FieldIndex]bool),
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.PayloadExpectedWithdrawals: oldRef,
-			},
-			payloadExpectedWithdrawals: []*enginev1.Withdrawal{{Index: 1}, {Index: 2}},
-		}
-
-		withdrawals := []*enginev1.Withdrawal{{Index: 3}}
-		require.NoError(t, st.SetPayloadExpectedWithdrawals(withdrawals))
-
-		require.DeepEqual(t, withdrawals, st.payloadExpectedWithdrawals)
-		require.Equal(t, true, st.dirtyFields[types.PayloadExpectedWithdrawals])
-
-		require.Equal(t, uint(1), oldRef.Refs())
-		require.Equal(t, uint(1), st.sharedFieldReferences[types.PayloadExpectedWithdrawals].Refs())
-		require.Equal(t, false, st.sharedFieldReferences[types.PayloadExpectedWithdrawals] == oldRef)
-	})
-}
-
-func TestDequeueBuilderPendingWithdrawals(t *testing.T) {
-	t.Run("previous fork returns expected error", func(t *testing.T) {
-		st := &BeaconState{version: version.Fulu}
-		err := st.DequeueBuilderPendingWithdrawals(1)
-		require.ErrorContains(t, "DequeueBuilderPendingWithdrawals", err)
-	})
-
-	t.Run("returns error when dequeueing more than length", func(t *testing.T) {
-		st := &BeaconState{
-			version:     version.Gloas,
-			dirtyFields: make(map[types.FieldIndex]bool),
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.BuilderPendingWithdrawals: stateutil.NewRef(1),
-			},
-			builderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{{Amount: 1}},
-		}
-
-		err := st.DequeueBuilderPendingWithdrawals(2)
-		require.ErrorContains(t, "cannot dequeue more builder withdrawals", err)
-		require.Equal(t, 1, len(st.builderPendingWithdrawals))
-		require.Equal(t, false, st.dirtyFields[types.BuilderPendingWithdrawals])
-	})
-
-	t.Run("no-op on zero", func(t *testing.T) {
-		st := &BeaconState{
-			version:     version.Gloas,
-			dirtyFields: make(map[types.FieldIndex]bool),
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.BuilderPendingWithdrawals: stateutil.NewRef(1),
-			},
-			builderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{{Amount: 1}},
-		}
-
-		require.NoError(t, st.DequeueBuilderPendingWithdrawals(0))
-		require.Equal(t, 1, len(st.builderPendingWithdrawals))
-		require.Equal(t, false, st.dirtyFields[types.BuilderPendingWithdrawals])
-		require.Equal(t, false, st.rebuildTrie[types.BuilderPendingWithdrawals])
-	})
-
-	t.Run("dequeues and marks dirty", func(t *testing.T) {
-		st := &BeaconState{
-			version:     version.Gloas,
-			dirtyFields: make(map[types.FieldIndex]bool),
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.BuilderPendingWithdrawals: stateutil.NewRef(1),
-			},
-			builderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{
-				{Amount: 1},
-				{Amount: 2},
-				{Amount: 3},
-			},
-			rebuildTrie: make(map[types.FieldIndex]bool),
-		}
-
-		require.NoError(t, st.DequeueBuilderPendingWithdrawals(2))
-		require.Equal(t, 1, len(st.builderPendingWithdrawals))
-		require.Equal(t, primitives.Gwei(3), st.builderPendingWithdrawals[0].Amount)
-		require.Equal(t, true, st.dirtyFields[types.BuilderPendingWithdrawals])
-		require.Equal(t, true, st.rebuildTrie[types.BuilderPendingWithdrawals])
-	})
-
-	t.Run("copy-on-write preserves shared state", func(t *testing.T) {
-		sharedRef := stateutil.NewRef(2)
-		sharedWithdrawals := []*ethpb.BuilderPendingWithdrawal{
-			{Amount: 1},
-			{Amount: 2},
-			{Amount: 3},
-		}
-
-		st1 := &BeaconState{
-			version:     version.Gloas,
-			dirtyFields: make(map[types.FieldIndex]bool),
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.BuilderPendingWithdrawals: sharedRef,
-			},
-			builderPendingWithdrawals: sharedWithdrawals,
-			rebuildTrie:               make(map[types.FieldIndex]bool),
-		}
-		st2 := &BeaconState{
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.BuilderPendingWithdrawals: sharedRef,
-			},
-			builderPendingWithdrawals: sharedWithdrawals,
-		}
-
-		require.NoError(t, st1.DequeueBuilderPendingWithdrawals(2))
-		require.Equal(t, primitives.Gwei(3), st1.builderPendingWithdrawals[0].Amount)
-		require.Equal(t, 3, len(st2.builderPendingWithdrawals))
-		require.Equal(t, primitives.Gwei(1), st2.builderPendingWithdrawals[0].Amount)
-		require.Equal(t, uint(1), st1.sharedFieldReferences[types.BuilderPendingWithdrawals].Refs())
-		require.Equal(t, uint(1), st2.sharedFieldReferences[types.BuilderPendingWithdrawals].Refs())
-	})
-}
-
-func TestSetNextWithdrawalBuilderIndex(t *testing.T) {
-	t.Run("previous fork returns expected error", func(t *testing.T) {
-		st := &BeaconState{version: version.Fulu}
-		err := st.SetNextWithdrawalBuilderIndex(1)
-		require.ErrorContains(t, "SetNextWithdrawalBuilderIndex", err)
-	})
-
-	t.Run("sets and marks dirty", func(t *testing.T) {
-		st := &BeaconState{
-			version:     version.Gloas,
-			dirtyFields: make(map[types.FieldIndex]bool),
-		}
-
-		require.NoError(t, st.SetNextWithdrawalBuilderIndex(7))
-		require.Equal(t, primitives.BuilderIndex(7), st.nextWithdrawalBuilderIndex)
-		require.Equal(t, true, st.dirtyFields[types.NextWithdrawalBuilderIndex])
-	})
-}
-
 func TestAppendBuilderPendingWithdrawal_CopyOnWrite(t *testing.T) {
 	wd := &ethpb.BuilderPendingWithdrawal{
 		FeeRecipient: make([]byte, 20),
@@ -476,59 +412,77 @@ func TestUpdateExecutionPayloadAvailabilityAtIndex_OutOfRange(t *testing.T) {
 	}
 }
 
-func TestDecreaseBuilderBalance(t *testing.T) {
-	t.Run("previous fork returns expected error", func(t *testing.T) {
-		st := &BeaconState{version: version.Fulu}
-		err := st.DecreaseBuilderBalance(0, 1)
-		require.ErrorContains(t, "DecreaseBuilderBalance", err)
-	})
+func buildGloasStateForPaymentWeightTest(
+	t *testing.T,
+	stateSlot primitives.Slot,
+	paymentIdx int,
+	amount primitives.Gwei,
+	weight primitives.Gwei,
+	roots map[primitives.Slot][]byte,
+) *BeaconState {
+	t.Helper()
 
-	t.Run("decreases and saturates", func(t *testing.T) {
-		st := &BeaconState{
-			version:      version.Gloas,
-			dirtyFields:  make(map[types.FieldIndex]bool),
-			dirtyIndices: make(map[types.FieldIndex][]uint64),
-			rebuildTrie:  make(map[types.FieldIndex]bool),
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.Builders: stateutil.NewRef(1),
-			},
-			builders: []*ethpb.Builder{
-				{Balance: 10},
+	cfg := params.BeaconConfig()
+	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for slot, root := range roots {
+		blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
+	}
+
+	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for i := range stateRoots {
+		stateRoots[i] = bytes.Repeat([]byte{0x44}, 32)
+	}
+	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
+	for i := range randaoMixes {
+		randaoMixes[i] = bytes.Repeat([]byte{0x55}, 32)
+	}
+
+	validator := &ethpb.Validator{
+		PublicKey:             bytes.Repeat([]byte{0x01}, 48),
+		WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x02}, 31)...),
+		EffectiveBalance:      cfg.MinActivationBalance,
+	}
+
+	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
+	for i := range payments {
+		payments[i] = &ethpb.BuilderPendingPayment{
+			Withdrawal: &ethpb.BuilderPendingWithdrawal{
+				FeeRecipient: make([]byte, 20),
 			},
 		}
+	}
+	payments[paymentIdx] = &ethpb.BuilderPendingPayment{
+		Weight: weight,
+		Withdrawal: &ethpb.BuilderPendingWithdrawal{
+			FeeRecipient: make([]byte, 20),
+			Amount:       amount,
+		},
+	}
 
-		require.NoError(t, st.DecreaseBuilderBalance(0, 3))
-		require.Equal(t, uint64(7), uint64(st.builders[0].Balance))
-		require.Equal(t, true, st.dirtyFields[types.Builders])
+	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
 
-		require.NoError(t, st.DecreaseBuilderBalance(0, 100))
-		require.Equal(t, uint64(0), uint64(st.builders[0].Balance))
-	})
+	stProto := &ethpb.BeaconStateGloas{
+		Slot:                         stateSlot,
+		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x33}, 32),
+		BlockRoots:                   blockRoots,
+		StateRoots:                   stateRoots,
+		RandaoMixes:                  randaoMixes,
+		ExecutionPayloadAvailability: execPayloadAvailability,
+		Validators:                   []*ethpb.Validator{validator},
+		Balances:                     []uint64{cfg.MinActivationBalance},
+		CurrentEpochParticipation:    []byte{0},
+		PreviousEpochParticipation:   []byte{0},
+		BuilderPendingPayments:       payments,
+		Fork: &ethpb.Fork{
+			CurrentVersion:  bytes.Repeat([]byte{0x66}, 4),
+			PreviousVersion: bytes.Repeat([]byte{0x66}, 4),
+			Epoch:           0,
+		},
+	}
 
-	t.Run("copy-on-write preserves shared state", func(t *testing.T) {
-		sharedRef := stateutil.NewRef(2)
-		sharedBuilders := []*ethpb.Builder{
-			{Balance: 10},
-		}
-
-		st1 := &BeaconState{
-			version:      version.Gloas,
-			dirtyFields:  make(map[types.FieldIndex]bool),
-			dirtyIndices: make(map[types.FieldIndex][]uint64),
-			rebuildTrie:  make(map[types.FieldIndex]bool),
-			sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-				types.Builders: sharedRef,
-			},
-			builders: sharedBuilders,
-		}
-		st2 := &BeaconState{
-			builders: sharedBuilders,
-		}
-
-		require.NoError(t, st1.DecreaseBuilderBalance(0, 3))
-		require.Equal(t, uint64(7), uint64(st1.builders[0].Balance))
-		require.Equal(t, uint64(10), uint64(st2.builders[0].Balance))
-	})
+	statePb, err := InitializeFromProtoGloas(stProto)
+	require.NoError(t, err)
+	return statePb.(*BeaconState)
 }
 
 func newGloasStateWithAvailability(t *testing.T, availability []byte) *BeaconState {

changelog/t_gloas-process-attestations.md

@@ -0,0 +1,3 @@
+### Added
+
+- Added process attestation for gloas

changelog/terencechain_refactor-expected-withdrawals.md

@@ -1,2 +0,0 @@
-### Ignored
-- Refactor expected withdrawals into reusable helpers for future forks.

config/params/config.go

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

config/params/loader.go

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

config/params/mainnet_config.go

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

config/params/testnet_config_test.go

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

consensus-types/blocks/getters_test.go

@@ -671,7 +671,7 @@ func hydrateBeaconBlockBodyGloas() *eth.BeaconBlockBodyGloas {
 				BlockHash:              make([]byte, fieldparams.RootLength),
 				PrevRandao:             make([]byte, fieldparams.RootLength),
 				FeeRecipient:           make([]byte, 20),
-				BlobKzgCommitments:     [][]byte{make([]byte, fieldparams.BLSPubkeyLength)},
+				BlobKzgCommitmentsRoot: make([]byte, fieldparams.RootLength),
 			},
 			Signature: make([]byte, fieldparams.BLSSignatureLength),
 		},

consensus-types/blocks/signed_execution_bid.go

@@ -1,7 +1,6 @@
 package blocks
 
 import (
-	field_params "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
 	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
@@ -44,17 +43,11 @@ func (h executionPayloadBidGloas) IsNil() bool {
 		len(h.payload.ParentBlockRoot) != 32 ||
 		len(h.payload.BlockHash) != 32 ||
 		len(h.payload.PrevRandao) != 32 ||
-		len(h.payload.BlobKzgCommitments) > field_params.MaxBlobCommitmentsPerBlock ||
+		len(h.payload.BlobKzgCommitmentsRoot) != 32 ||
 		len(h.payload.FeeRecipient) != 20 {
 		return true
 	}
 
-	for _, commitment := range h.payload.BlobKzgCommitments {
-		if len(commitment) != 48 {
-			return true
-		}
-	}
-
 	return false
 }
 
@@ -138,9 +131,9 @@ func (h executionPayloadBidGloas) ExecutionPayment() primitives.Gwei {
 	return primitives.Gwei(h.payload.ExecutionPayment)
 }
 
-// BlobKzgCommitments returns the KZG commitments for blobs.
-func (h executionPayloadBidGloas) BlobKzgCommitments() [][]byte {
-	return h.payload.BlobKzgCommitments
+// BlobKzgCommitmentsRoot returns the root of the KZG commitments for blobs.
+func (h executionPayloadBidGloas) BlobKzgCommitmentsRoot() [32]byte {
+	return [32]byte(h.payload.BlobKzgCommitmentsRoot)
 }
 
 // FeeRecipient returns the execution address that will receive the builder payment.

consensus-types/blocks/signed_execution_bid_test.go

@@ -24,7 +24,7 @@ func validExecutionPayloadBid() *ethpb.ExecutionPayloadBid {
 		Slot:                   6,
 		Value:                  7,
 		ExecutionPayment:       8,
-		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0x05}, 48)},
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x05}, 32),
 		FeeRecipient:           bytes.Repeat([]byte{0x06}, 20),
 	}
 }
@@ -52,8 +52,8 @@ func TestWrappedROExecutionPayloadBid(t *testing.T) {
 				mutate: func(b *ethpb.ExecutionPayloadBid) { b.PrevRandao = []byte{0x04} },
 			},
 			{
-				name:   "blob kzg commitments length",
-				mutate: func(b *ethpb.ExecutionPayloadBid) { b.BlobKzgCommitments = [][]byte{[]byte{0x05}} },
+				name:   "blob kzg commitments root",
+				mutate: func(b *ethpb.ExecutionPayloadBid) { b.BlobKzgCommitmentsRoot = []byte{0x05} },
 			},
 			{
 				name:   "fee recipient",
@@ -85,7 +85,7 @@ func TestWrappedROExecutionPayloadBid(t *testing.T) {
 		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x02}, 32)), wrapped.ParentBlockRoot())
 		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x03}, 32)), wrapped.BlockHash())
 		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x04}, 32)), wrapped.PrevRandao())
-		assert.DeepEqual(t, [][]byte{bytes.Repeat([]byte{0x05}, 48)}, wrapped.BlobKzgCommitments())
+		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x05}, 32)), wrapped.BlobKzgCommitmentsRoot())
 		assert.DeepEqual(t, [20]byte(bytes.Repeat([]byte{0x06}, 20)), wrapped.FeeRecipient())
 	})
 }

consensus-types/interfaces/signed_execution_payload_bid.go

@@ -22,7 +22,7 @@ type ROExecutionPayloadBid interface {
 	Slot() primitives.Slot
 	Value() primitives.Gwei
 	ExecutionPayment() primitives.Gwei
-	BlobKzgCommitments() [][]byte
+	BlobKzgCommitmentsRoot() [32]byte
 	FeeRecipient() [20]byte
 	IsNil() bool
 }

consensus-types/primitives/builder_index.go

@@ -13,15 +13,6 @@ var _ fssz.Unmarshaler = (*BuilderIndex)(nil)
 // BuilderIndex is an index into the builder registry.
 type BuilderIndex uint64
 
-// ToValidatorIndex sets the builder flag on a builder index.
-//
-// Spec v1.6.1 (pseudocode):
-// def convert_builder_index_to_validator_index(builder_index: BuilderIndex) -> ValidatorIndex:
-//     return ValidatorIndex(builder_index | BUILDER_INDEX_FLAG)
-func (b BuilderIndex) ToValidatorIndex() ValidatorIndex {
-	return ValidatorIndex(uint64(b) | BuilderIndexFlag)
-}
-
 // HashTreeRoot returns the SSZ hash tree root of the index.
 func (b BuilderIndex) HashTreeRoot() ([32]byte, error) {
 	return fssz.HashWithDefaultHasher(b)

consensus-types/primitives/validator.go

@@ -10,32 +10,9 @@ var _ fssz.HashRoot = (ValidatorIndex)(0)
 var _ fssz.Marshaler = (*ValidatorIndex)(nil)
 var _ fssz.Unmarshaler = (*ValidatorIndex)(nil)
 
-// BuilderIndexFlag marks a ValidatorIndex as a BuilderIndex when the bit is set.
-//
-// Spec v1.6.1: BUILDER_INDEX_FLAG.
-const BuilderIndexFlag uint64 = 1 << 40
-
 // ValidatorIndex in eth2.
 type ValidatorIndex uint64
 
-// IsBuilderIndex returns true when the BuilderIndex flag is set on the validator index.
-//
-// Spec v1.6.1 (pseudocode):
-// def is_builder_index(validator_index: ValidatorIndex) -> bool:
-//     return (validator_index & BUILDER_INDEX_FLAG) != 0
-func (v ValidatorIndex) IsBuilderIndex() bool {
-	return uint64(v)&BuilderIndexFlag != 0
-}
-
-// ToBuilderIndex strips the builder flag from a validator index.
-//
-// Spec v1.6.1 (pseudocode):
-// def convert_validator_index_to_builder_index(validator_index: ValidatorIndex) -> BuilderIndex:
-//     return BuilderIndex(validator_index & ~BUILDER_INDEX_FLAG)
-func (v ValidatorIndex) ToBuilderIndex() BuilderIndex {
-	return BuilderIndex(uint64(v) & ^BuilderIndexFlag)
-}
-
 // Div divides validator index by x.
 // This method panics if dividing by zero!
 func (v ValidatorIndex) Div(x uint64) ValidatorIndex {

consensus-types/primitives/validator_test.go

@@ -33,32 +33,3 @@ func TestValidatorIndex_Casting(t *testing.T) {
 		}
 	})
 }
-
-func TestValidatorIndex_BuilderIndexFlagConversions(t *testing.T) {
-	base := uint64(42)
-
-	unflagged := ValidatorIndex(base)
-	if unflagged.IsBuilderIndex() {
-		t.Fatalf("expected unflagged validator index to not be a builder index")
-	}
-	if got, want := unflagged.ToBuilderIndex(), BuilderIndex(base); got != want {
-		t.Fatalf("unexpected builder index: got %d want %d", got, want)
-	}
-
-	flagged := ValidatorIndex(base | BuilderIndexFlag)
-	if !flagged.IsBuilderIndex() {
-		t.Fatalf("expected flagged validator index to be a builder index")
-	}
-	if got, want := flagged.ToBuilderIndex(), BuilderIndex(base); got != want {
-		t.Fatalf("unexpected builder index: got %d want %d", got, want)
-	}
-
-	builder := BuilderIndex(base)
-	roundTrip := builder.ToValidatorIndex()
-	if !roundTrip.IsBuilderIndex() {
-		t.Fatalf("expected round-tripped validator index to be a builder index")
-	}
-	if got, want := roundTrip.ToBuilderIndex(), builder; got != want {
-		t.Fatalf("unexpected round-trip builder index: got %d want %d", got, want)
-	}
-}

proto/dbval/dbval.pb.go

@@ -7,10 +7,11 @@
 package dbval
 
 import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
 	sync "sync"
+
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 )
 
 const (

proto/engine/v1/electra.pb.go

@@ -7,11 +7,12 @@
 package enginev1
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/engine/v1/execution_engine.pb.go

@@ -7,12 +7,13 @@
 package enginev1
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/engine/v1/fulu.pb.go

@@ -7,10 +7,11 @@
 package enginev1
 
 import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
 	sync "sync"
+
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 )
 
 const (

proto/eth/ext/options.pb.go

@@ -7,10 +7,11 @@
 package ext
 
 import (
+	reflect "reflect"
+
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
 )
 
 const (

proto/eth/v1/attestation.pb.go

@@ -7,14 +7,15 @@
 package v1
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_go_bitfield "github.com/OffchainLabs/go-bitfield"
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	_ "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/eth/v1/beacon_block.pb.go

@@ -7,14 +7,15 @@
 package v1
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_go_bitfield "github.com/OffchainLabs/go-bitfield"
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	_ "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/eth/v1/beacon_chain.pb.go

@@ -7,11 +7,12 @@
 package v1
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	_ "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/eth/v1/events.pb.go

@@ -7,13 +7,14 @@
 package v1
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	_ "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/eth/v1/node.pb.go

@@ -7,11 +7,12 @@
 package v1
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	_ "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/eth/v1/validator.pb.go

@@ -7,13 +7,14 @@
 package v1
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	_ "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/attestation.pb.go

@@ -7,13 +7,14 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_go_bitfield "github.com/OffchainLabs/go-bitfield"
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/beacon_block.pb.go

@@ -7,13 +7,14 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	v1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/beacon_chain.pb.go

@@ -8,6 +8,9 @@ package eth
 
 import (
 	context "context"
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	_ "google.golang.org/genproto/googleapis/api/annotations"
@@ -17,8 +20,6 @@ import (
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/beacon_core_types.pb.go

@@ -7,13 +7,14 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_go_bitfield "github.com/OffchainLabs/go-bitfield"
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/beacon_state.pb.go

@@ -7,14 +7,15 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_go_bitfield "github.com/OffchainLabs/go-bitfield"
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	v1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/blobs.pb.go

@@ -7,12 +7,13 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/cloners.go

@@ -147,14 +147,12 @@ func copySignedExecutionPayloadBid(header *SignedExecutionPayloadBid) *SignedExe
 			ParentBlockHash:        bytesutil.SafeCopyBytes(header.Message.ParentBlockHash),
 			ParentBlockRoot:        bytesutil.SafeCopyBytes(header.Message.ParentBlockRoot),
 			BlockHash:              bytesutil.SafeCopyBytes(header.Message.BlockHash),
-			PrevRandao:             bytesutil.SafeCopyBytes(header.Message.PrevRandao),
 			FeeRecipient:           bytesutil.SafeCopyBytes(header.Message.FeeRecipient),
 			GasLimit:               header.Message.GasLimit,
 			BuilderIndex:           header.Message.BuilderIndex,
 			Slot:                   header.Message.Slot,
 			Value:                  header.Message.Value,
-			ExecutionPayment:       header.Message.ExecutionPayment,
-			BlobKzgCommitments:     bytesutil.SafeCopy2dBytes(header.Message.BlobKzgCommitments),
+			BlobKzgCommitmentsRoot: bytesutil.SafeCopyBytes(header.Message.BlobKzgCommitmentsRoot),
 		}
 	}
 	return copied

proto/prysm/v1alpha1/cloners_test.go

@@ -1223,7 +1223,7 @@ func genExecutionPayloadBidGloas() *v1alpha1.ExecutionPayloadBid {
 		BuilderIndex:           primitives.BuilderIndex(rand.Uint64()),
 		Slot:                   primitives.Slot(rand.Uint64()),
 		Value:                  primitives.Gwei(rand.Uint64()),
-		BlobKzgCommitments:     [][]byte{bytes(48)},
+		BlobKzgCommitmentsRoot: bytes(32),
 	}
 }
 

proto/prysm/v1alpha1/data_columns.pb.go

@@ -7,11 +7,12 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/debug.pb.go

@@ -8,6 +8,9 @@ package eth
 
 import (
 	context "context"
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	_ "google.golang.org/genproto/googleapis/api/annotations"
@@ -17,8 +20,6 @@ import (
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/eip_7251.pb.go

@@ -7,12 +7,13 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/finalized_block_root_container.pb.go

@@ -7,10 +7,11 @@
 package eth
 
 import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
 	sync "sync"
+
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 )
 
 const (

proto/prysm/v1alpha1/gloas.go

@@ -20,7 +20,7 @@ func (header *ExecutionPayloadBid) Copy() *ExecutionPayloadBid {
 		Slot:                   header.Slot,
 		Value:                  header.Value,
 		ExecutionPayment:       header.ExecutionPayment,
-		BlobKzgCommitments:     bytesutil.SafeCopy2dBytes(header.BlobKzgCommitments),
+		BlobKzgCommitmentsRoot: bytesutil.SafeCopyBytes(header.BlobKzgCommitmentsRoot),
 	}
 }
 

proto/prysm/v1alpha1/gloas.proto

@@ -33,7 +33,7 @@ option go_package = "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1;eth";
 //     slot: Slot
 //     value: Gwei
 //     execution_payment: Gwei
-//     blob_kzg_commitments: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+//     blob_kzg_commitments_root: Root
 message ExecutionPayloadBid {
   bytes parent_block_hash = 1 [ (ethereum.eth.ext.ssz_size) = "32" ];
   bytes parent_block_root = 2 [ (ethereum.eth.ext.ssz_size) = "32" ];
@@ -56,10 +56,7 @@ message ExecutionPayloadBid {
     (ethereum.eth.ext.cast_type) =
         "github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Gwei"
   ];
-  repeated bytes blob_kzg_commitments = 11 [
-    (ethereum.eth.ext.ssz_size) = "?,48",
-    (ethereum.eth.ext.ssz_max) = "max_blob_commitments.size"
-  ];
+  bytes blob_kzg_commitments_root = 11 [ (ethereum.eth.ext.ssz_size) = "32" ];
 }
 
 // SignedExecutionPayloadBid wraps an execution payload bid with a signature.
@@ -405,6 +402,7 @@ message DataColumnSidecarGloas {
 //     builder_index: BuilderIndex
 //     beacon_block_root: Root
 //     slot: Slot
+//     blob_kzg_commitments: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]
 //     state_root: Root
 message ExecutionPayloadEnvelope {
   ethereum.engine.v1.ExecutionPayloadDeneb payload = 1;
@@ -417,6 +415,10 @@ message ExecutionPayloadEnvelope {
     (ethereum.eth.ext.cast_type) =
         "github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Slot"
   ];
+  repeated bytes blob_kzg_commitments = 6 [
+    (ethereum.eth.ext.ssz_size) = "?,48",
+    (ethereum.eth.ext.ssz_max) = "max_blob_commitments.size"
+  ];
   bytes state_root = 7 [ (ethereum.eth.ext.ssz_size) = "32" ];
 }
 

proto/prysm/v1alpha1/gloas.ssz.go

@@ -15,7 +15,6 @@ func (e *ExecutionPayloadBid) MarshalSSZ() ([]byte, error) {
 // MarshalSSZTo ssz marshals the ExecutionPayloadBid object to a target array
 func (e *ExecutionPayloadBid) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	dst = buf
-	offset := int(192)
 
 	// Field (0) 'ParentBlockHash'
 	if size := len(e.ParentBlockHash); size != 32 {
@@ -67,22 +66,12 @@ func (e *ExecutionPayloadBid) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	// Field (9) 'ExecutionPayment'
 	dst = ssz.MarshalUint64(dst, uint64(e.ExecutionPayment))
 
-	// Offset (10) 'BlobKzgCommitments'
-	dst = ssz.WriteOffset(dst, offset)
-	offset += len(e.BlobKzgCommitments) * 48
-
-	// Field (10) 'BlobKzgCommitments'
-	if size := len(e.BlobKzgCommitments); size > 4096 {
-		err = ssz.ErrListTooBigFn("--.BlobKzgCommitments", size, 4096)
+	// Field (10) 'BlobKzgCommitmentsRoot'
+	if size := len(e.BlobKzgCommitmentsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlobKzgCommitmentsRoot", size, 32)
 		return
 	}
-	for ii := 0; ii < len(e.BlobKzgCommitments); ii++ {
-		if size := len(e.BlobKzgCommitments[ii]); size != 48 {
-			err = ssz.ErrBytesLengthFn("--.BlobKzgCommitments[ii]", size, 48)
-			return
-		}
-		dst = append(dst, e.BlobKzgCommitments[ii]...)
-	}
+	dst = append(dst, e.BlobKzgCommitmentsRoot...)
 
 	return
 }
@@ -91,13 +80,10 @@ func (e *ExecutionPayloadBid) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 func (e *ExecutionPayloadBid) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size < 192 {
+	if size != 220 {
 		return ssz.ErrSize
 	}
 
-	tail := buf
-	var o10 uint64
-
 	// Field (0) 'ParentBlockHash'
 	if cap(e.ParentBlockHash) == 0 {
 		e.ParentBlockHash = make([]byte, 0, len(buf[0:32]))
@@ -143,40 +129,18 @@ func (e *ExecutionPayloadBid) UnmarshalSSZ(buf []byte) error {
 	// Field (9) 'ExecutionPayment'
 	e.ExecutionPayment = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[180:188]))
 
-	// Offset (10) 'BlobKzgCommitments'
-	if o10 = ssz.ReadOffset(buf[188:192]); o10 > size {
-		return ssz.ErrOffset
+	// Field (10) 'BlobKzgCommitmentsRoot'
+	if cap(e.BlobKzgCommitmentsRoot) == 0 {
+		e.BlobKzgCommitmentsRoot = make([]byte, 0, len(buf[188:220]))
 	}
+	e.BlobKzgCommitmentsRoot = append(e.BlobKzgCommitmentsRoot, buf[188:220]...)
 
-	if o10 != 192 {
-		return ssz.ErrInvalidVariableOffset
-	}
-
-	// Field (10) 'BlobKzgCommitments'
-	{
-		buf = tail[o10:]
-		num, err := ssz.DivideInt2(len(buf), 48, 4096)
-		if err != nil {
-			return err
-		}
-		e.BlobKzgCommitments = make([][]byte, num)
-		for ii := 0; ii < num; ii++ {
-			if cap(e.BlobKzgCommitments[ii]) == 0 {
-				e.BlobKzgCommitments[ii] = make([]byte, 0, len(buf[ii*48:(ii+1)*48]))
-			}
-			e.BlobKzgCommitments[ii] = append(e.BlobKzgCommitments[ii], buf[ii*48:(ii+1)*48]...)
-		}
-	}
 	return err
 }
 
 // SizeSSZ returns the ssz encoded size in bytes for the ExecutionPayloadBid object
 func (e *ExecutionPayloadBid) SizeSSZ() (size int) {
-	size = 192
-
-	// Field (10) 'BlobKzgCommitments'
-	size += len(e.BlobKzgCommitments) * 48
-
+	size = 220
 	return
 }
 
@@ -239,24 +203,12 @@ func (e *ExecutionPayloadBid) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 	// Field (9) 'ExecutionPayment'
 	hh.PutUint64(uint64(e.ExecutionPayment))
 
-	// Field (10) 'BlobKzgCommitments'
-	{
-		if size := len(e.BlobKzgCommitments); size > 4096 {
-			err = ssz.ErrListTooBigFn("--.BlobKzgCommitments", size, 4096)
-			return
-		}
-		subIndx := hh.Index()
-		for _, i := range e.BlobKzgCommitments {
-			if len(i) != 48 {
-				err = ssz.ErrBytesLength
-				return
-			}
-			hh.PutBytes(i)
-		}
-
-		numItems := uint64(len(e.BlobKzgCommitments))
-		hh.MerkleizeWithMixin(subIndx, numItems, 4096)
+	// Field (10) 'BlobKzgCommitmentsRoot'
+	if size := len(e.BlobKzgCommitmentsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlobKzgCommitmentsRoot", size, 32)
+		return
 	}
+	hh.PutBytes(e.BlobKzgCommitmentsRoot)
 
 	hh.Merkleize(indx)
 	return
@@ -270,14 +222,14 @@ func (s *SignedExecutionPayloadBid) MarshalSSZ() ([]byte, error) {
 // MarshalSSZTo ssz marshals the SignedExecutionPayloadBid object to a target array
 func (s *SignedExecutionPayloadBid) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	dst = buf
-	offset := int(100)
 
-	// Offset (0) 'Message'
-	dst = ssz.WriteOffset(dst, offset)
+	// Field (0) 'Message'
 	if s.Message == nil {
 		s.Message = new(ExecutionPayloadBid)
 	}
-	offset += s.Message.SizeSSZ()
+	if dst, err = s.Message.MarshalSSZTo(dst); err != nil {
+		return
+	}
 
 	// Field (1) 'Signature'
 	if size := len(s.Signature); size != 96 {
@@ -286,11 +238,6 @@ func (s *SignedExecutionPayloadBid) MarshalSSZTo(buf []byte) (dst []byte, err er
 	}
 	dst = append(dst, s.Signature...)
 
-	// Field (0) 'Message'
-	if dst, err = s.Message.MarshalSSZTo(dst); err != nil {
-		return
-	}
-
 	return
 }
 
@@ -298,51 +245,30 @@ func (s *SignedExecutionPayloadBid) MarshalSSZTo(buf []byte) (dst []byte, err er
 func (s *SignedExecutionPayloadBid) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size < 100 {
+	if size != 316 {
 		return ssz.ErrSize
 	}
 
-	tail := buf
-	var o0 uint64
-
-	// Offset (0) 'Message'
-	if o0 = ssz.ReadOffset(buf[0:4]); o0 > size {
-		return ssz.ErrOffset
-	}
-
-	if o0 != 100 {
-		return ssz.ErrInvalidVariableOffset
-	}
-
-	// Field (1) 'Signature'
-	if cap(s.Signature) == 0 {
-		s.Signature = make([]byte, 0, len(buf[4:100]))
-	}
-	s.Signature = append(s.Signature, buf[4:100]...)
-
-	// Field (0) 'Message'
-	{
-		buf = tail[o0:]
-		if s.Message == nil {
-			s.Message = new(ExecutionPayloadBid)
-		}
-		if err = s.Message.UnmarshalSSZ(buf); err != nil {
-			return err
-		}
-	}
-	return err
-}
-
-// SizeSSZ returns the ssz encoded size in bytes for the SignedExecutionPayloadBid object
-func (s *SignedExecutionPayloadBid) SizeSSZ() (size int) {
-	size = 100
-
 	// Field (0) 'Message'
 	if s.Message == nil {
 		s.Message = new(ExecutionPayloadBid)
 	}
-	size += s.Message.SizeSSZ()
+	if err = s.Message.UnmarshalSSZ(buf[0:220]); err != nil {
+		return err
+	}
 
+	// Field (1) 'Signature'
+	if cap(s.Signature) == 0 {
+		s.Signature = make([]byte, 0, len(buf[220:316]))
+	}
+	s.Signature = append(s.Signature, buf[220:316]...)
+
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the SignedExecutionPayloadBid object
+func (s *SignedExecutionPayloadBid) SizeSSZ() (size int) {
+	size = 316
 	return
 }
 
@@ -816,7 +742,7 @@ func (b *BeaconBlockBodyGloas) MarshalSSZ() ([]byte, error) {
 // MarshalSSZTo ssz marshals the BeaconBlockBodyGloas object to a target array
 func (b *BeaconBlockBodyGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	dst = buf
-	offset := int(392)
+	offset := int(704)
 
 	// Field (0) 'RandaoReveal'
 	if size := len(b.RandaoReveal); size != 96 {
@@ -878,12 +804,13 @@ func (b *BeaconBlockBodyGloas) MarshalSSZTo(buf []byte) (dst []byte, err error)
 	dst = ssz.WriteOffset(dst, offset)
 	offset += len(b.BlsToExecutionChanges) * 172
 
-	// Offset (10) 'SignedExecutionPayloadBid'
-	dst = ssz.WriteOffset(dst, offset)
+	// Field (10) 'SignedExecutionPayloadBid'
 	if b.SignedExecutionPayloadBid == nil {
 		b.SignedExecutionPayloadBid = new(SignedExecutionPayloadBid)
 	}
-	offset += b.SignedExecutionPayloadBid.SizeSSZ()
+	if dst, err = b.SignedExecutionPayloadBid.MarshalSSZTo(dst); err != nil {
+		return
+	}
 
 	// Offset (11) 'PayloadAttestations'
 	dst = ssz.WriteOffset(dst, offset)
@@ -969,11 +896,6 @@ func (b *BeaconBlockBodyGloas) MarshalSSZTo(buf []byte) (dst []byte, err error)
 		}
 	}
 
-	// Field (10) 'SignedExecutionPayloadBid'
-	if dst, err = b.SignedExecutionPayloadBid.MarshalSSZTo(dst); err != nil {
-		return
-	}
-
 	// Field (11) 'PayloadAttestations'
 	if size := len(b.PayloadAttestations); size > 4 {
 		err = ssz.ErrListTooBigFn("--.PayloadAttestations", size, 4)
@@ -992,12 +914,12 @@ func (b *BeaconBlockBodyGloas) MarshalSSZTo(buf []byte) (dst []byte, err error)
 func (b *BeaconBlockBodyGloas) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size < 392 {
+	if size < 704 {
 		return ssz.ErrSize
 	}
 
 	tail := buf
-	var o3, o4, o5, o6, o7, o9, o10, o11 uint64
+	var o3, o4, o5, o6, o7, o9, o11 uint64
 
 	// Field (0) 'RandaoReveal'
 	if cap(b.RandaoReveal) == 0 {
@@ -1024,7 +946,7 @@ func (b *BeaconBlockBodyGloas) UnmarshalSSZ(buf []byte) error {
 		return ssz.ErrOffset
 	}
 
-	if o3 != 392 {
+	if o3 != 704 {
 		return ssz.ErrInvalidVariableOffset
 	}
 
@@ -1061,13 +983,16 @@ func (b *BeaconBlockBodyGloas) UnmarshalSSZ(buf []byte) error {
 		return ssz.ErrOffset
 	}
 
-	// Offset (10) 'SignedExecutionPayloadBid'
-	if o10 = ssz.ReadOffset(buf[384:388]); o10 > size || o9 > o10 {
-		return ssz.ErrOffset
+	// Field (10) 'SignedExecutionPayloadBid'
+	if b.SignedExecutionPayloadBid == nil {
+		b.SignedExecutionPayloadBid = new(SignedExecutionPayloadBid)
+	}
+	if err = b.SignedExecutionPayloadBid.UnmarshalSSZ(buf[384:700]); err != nil {
+		return err
 	}
 
 	// Offset (11) 'PayloadAttestations'
-	if o11 = ssz.ReadOffset(buf[388:392]); o11 > size || o10 > o11 {
+	if o11 = ssz.ReadOffset(buf[700:704]); o11 > size || o9 > o11 {
 		return ssz.ErrOffset
 	}
 
@@ -1171,7 +1096,7 @@ func (b *BeaconBlockBodyGloas) UnmarshalSSZ(buf []byte) error {
 
 	// Field (9) 'BlsToExecutionChanges'
 	{
-		buf = tail[o9:o10]
+		buf = tail[o9:o11]
 		num, err := ssz.DivideInt2(len(buf), 172, 16)
 		if err != nil {
 			return err
@@ -1187,17 +1112,6 @@ func (b *BeaconBlockBodyGloas) UnmarshalSSZ(buf []byte) error {
 		}
 	}
 
-	// Field (10) 'SignedExecutionPayloadBid'
-	{
-		buf = tail[o10:o11]
-		if b.SignedExecutionPayloadBid == nil {
-			b.SignedExecutionPayloadBid = new(SignedExecutionPayloadBid)
-		}
-		if err = b.SignedExecutionPayloadBid.UnmarshalSSZ(buf); err != nil {
-			return err
-		}
-	}
-
 	// Field (11) 'PayloadAttestations'
 	{
 		buf = tail[o11:]
@@ -1220,7 +1134,7 @@ func (b *BeaconBlockBodyGloas) UnmarshalSSZ(buf []byte) error {
 
 // SizeSSZ returns the ssz encoded size in bytes for the BeaconBlockBodyGloas object
 func (b *BeaconBlockBodyGloas) SizeSSZ() (size int) {
-	size = 392
+	size = 704
 
 	// Field (3) 'ProposerSlashings'
 	size += len(b.ProposerSlashings) * 416
@@ -1246,12 +1160,6 @@ func (b *BeaconBlockBodyGloas) SizeSSZ() (size int) {
 	// Field (9) 'BlsToExecutionChanges'
 	size += len(b.BlsToExecutionChanges) * 172
 
-	// Field (10) 'SignedExecutionPayloadBid'
-	if b.SignedExecutionPayloadBid == nil {
-		b.SignedExecutionPayloadBid = new(SignedExecutionPayloadBid)
-	}
-	size += b.SignedExecutionPayloadBid.SizeSSZ()
-
 	// Field (11) 'PayloadAttestations'
 	size += len(b.PayloadAttestations) * 202
 
@@ -1529,7 +1437,7 @@ func (b *BeaconStateGloas) MarshalSSZ() ([]byte, error) {
 // MarshalSSZTo ssz marshals the BeaconStateGloas object to a target array
 func (b *BeaconStateGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	dst = buf
-	offset := int(2741117)
+	offset := int(2741333)
 
 	// Field (0) 'GenesisTime'
 	dst = ssz.MarshalUint64(dst, b.GenesisTime)
@@ -1694,12 +1602,13 @@ func (b *BeaconStateGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 		return
 	}
 
-	// Offset (24) 'LatestExecutionPayloadBid'
-	dst = ssz.WriteOffset(dst, offset)
+	// Field (24) 'LatestExecutionPayloadBid'
 	if b.LatestExecutionPayloadBid == nil {
 		b.LatestExecutionPayloadBid = new(ExecutionPayloadBid)
 	}
-	offset += b.LatestExecutionPayloadBid.SizeSSZ()
+	if dst, err = b.LatestExecutionPayloadBid.MarshalSSZTo(dst); err != nil {
+		return
+	}
 
 	// Field (25) 'NextWithdrawalIndex'
 	dst = ssz.MarshalUint64(dst, b.NextWithdrawalIndex)
@@ -1857,11 +1766,6 @@ func (b *BeaconStateGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 		dst = ssz.MarshalUint64(dst, b.InactivityScores[ii])
 	}
 
-	// Field (24) 'LatestExecutionPayloadBid'
-	if dst, err = b.LatestExecutionPayloadBid.MarshalSSZTo(dst); err != nil {
-		return
-	}
-
 	// Field (27) 'HistoricalSummaries'
 	if size := len(b.HistoricalSummaries); size > 16777216 {
 		err = ssz.ErrListTooBigFn("--.HistoricalSummaries", size, 16777216)
@@ -1946,12 +1850,12 @@ func (b *BeaconStateGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size < 2741117 {
+	if size < 2741333 {
 		return ssz.ErrSize
 	}
 
 	tail := buf
-	var o7, o9, o11, o12, o15, o16, o21, o24, o27, o34, o35, o36, o38, o42, o44 uint64
+	var o7, o9, o11, o12, o15, o16, o21, o27, o34, o35, o36, o38, o42, o44 uint64
 
 	// Field (0) 'GenesisTime'
 	b.GenesisTime = ssz.UnmarshallUint64(buf[0:8])
@@ -2004,7 +1908,7 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 		return ssz.ErrOffset
 	}
 
-	if o7 != 2741117 {
+	if o7 != 2741333 {
 		return ssz.ErrInvalidVariableOffset
 	}
 
@@ -2110,74 +2014,77 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 		return err
 	}
 
-	// Offset (24) 'LatestExecutionPayloadBid'
-	if o24 = ssz.ReadOffset(buf[2736629:2736633]); o24 > size || o21 > o24 {
-		return ssz.ErrOffset
+	// Field (24) 'LatestExecutionPayloadBid'
+	if b.LatestExecutionPayloadBid == nil {
+		b.LatestExecutionPayloadBid = new(ExecutionPayloadBid)
+	}
+	if err = b.LatestExecutionPayloadBid.UnmarshalSSZ(buf[2736629:2736849]); err != nil {
+		return err
 	}
 
 	// Field (25) 'NextWithdrawalIndex'
-	b.NextWithdrawalIndex = ssz.UnmarshallUint64(buf[2736633:2736641])
+	b.NextWithdrawalIndex = ssz.UnmarshallUint64(buf[2736849:2736857])
 
 	// Field (26) 'NextWithdrawalValidatorIndex'
-	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736641:2736649]))
+	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736857:2736865]))
 
 	// Offset (27) 'HistoricalSummaries'
-	if o27 = ssz.ReadOffset(buf[2736649:2736653]); o27 > size || o24 > o27 {
+	if o27 = ssz.ReadOffset(buf[2736865:2736869]); o27 > size || o21 > o27 {
 		return ssz.ErrOffset
 	}
 
 	// Field (28) 'DepositRequestsStartIndex'
-	b.DepositRequestsStartIndex = ssz.UnmarshallUint64(buf[2736653:2736661])
+	b.DepositRequestsStartIndex = ssz.UnmarshallUint64(buf[2736869:2736877])
 
 	// Field (29) 'DepositBalanceToConsume'
-	b.DepositBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736661:2736669]))
+	b.DepositBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736877:2736885]))
 
 	// Field (30) 'ExitBalanceToConsume'
-	b.ExitBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736669:2736677]))
+	b.ExitBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736885:2736893]))
 
 	// Field (31) 'EarliestExitEpoch'
-	b.EarliestExitEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736677:2736685]))
+	b.EarliestExitEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736893:2736901]))
 
 	// Field (32) 'ConsolidationBalanceToConsume'
-	b.ConsolidationBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736685:2736693]))
+	b.ConsolidationBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736901:2736909]))
 
 	// Field (33) 'EarliestConsolidationEpoch'
-	b.EarliestConsolidationEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736693:2736701]))
+	b.EarliestConsolidationEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736909:2736917]))
 
 	// Offset (34) 'PendingDeposits'
-	if o34 = ssz.ReadOffset(buf[2736701:2736705]); o34 > size || o27 > o34 {
+	if o34 = ssz.ReadOffset(buf[2736917:2736921]); o34 > size || o27 > o34 {
 		return ssz.ErrOffset
 	}
 
 	// Offset (35) 'PendingPartialWithdrawals'
-	if o35 = ssz.ReadOffset(buf[2736705:2736709]); o35 > size || o34 > o35 {
+	if o35 = ssz.ReadOffset(buf[2736921:2736925]); o35 > size || o34 > o35 {
 		return ssz.ErrOffset
 	}
 
 	// Offset (36) 'PendingConsolidations'
-	if o36 = ssz.ReadOffset(buf[2736709:2736713]); o36 > size || o35 > o36 {
+	if o36 = ssz.ReadOffset(buf[2736925:2736929]); o36 > size || o35 > o36 {
 		return ssz.ErrOffset
 	}
 
 	// Field (37) 'ProposerLookahead'
 	b.ProposerLookahead = ssz.ExtendUint64(b.ProposerLookahead, 64)
 	for ii := 0; ii < 64; ii++ {
-		b.ProposerLookahead[ii] = ssz.UnmarshallUint64(buf[2736713:2737225][ii*8 : (ii+1)*8])
+		b.ProposerLookahead[ii] = ssz.UnmarshallUint64(buf[2736929:2737441][ii*8 : (ii+1)*8])
 	}
 
 	// Offset (38) 'Builders'
-	if o38 = ssz.ReadOffset(buf[2737225:2737229]); o38 > size || o36 > o38 {
+	if o38 = ssz.ReadOffset(buf[2737441:2737445]); o38 > size || o36 > o38 {
 		return ssz.ErrOffset
 	}
 
 	// Field (39) 'NextWithdrawalBuilderIndex'
-	b.NextWithdrawalBuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.BuilderIndex(ssz.UnmarshallUint64(buf[2737229:2737237]))
+	b.NextWithdrawalBuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.BuilderIndex(ssz.UnmarshallUint64(buf[2737445:2737453]))
 
 	// Field (40) 'ExecutionPayloadAvailability'
 	if cap(b.ExecutionPayloadAvailability) == 0 {
-		b.ExecutionPayloadAvailability = make([]byte, 0, len(buf[2737237:2738261]))
+		b.ExecutionPayloadAvailability = make([]byte, 0, len(buf[2737453:2738477]))
 	}
-	b.ExecutionPayloadAvailability = append(b.ExecutionPayloadAvailability, buf[2737237:2738261]...)
+	b.ExecutionPayloadAvailability = append(b.ExecutionPayloadAvailability, buf[2737453:2738477]...)
 
 	// Field (41) 'BuilderPendingPayments'
 	b.BuilderPendingPayments = make([]*BuilderPendingPayment, 64)
@@ -2185,24 +2092,24 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 		if b.BuilderPendingPayments[ii] == nil {
 			b.BuilderPendingPayments[ii] = new(BuilderPendingPayment)
 		}
-		if err = b.BuilderPendingPayments[ii].UnmarshalSSZ(buf[2738261:2741077][ii*44 : (ii+1)*44]); err != nil {
+		if err = b.BuilderPendingPayments[ii].UnmarshalSSZ(buf[2738477:2741293][ii*44 : (ii+1)*44]); err != nil {
 			return err
 		}
 	}
 
 	// Offset (42) 'BuilderPendingWithdrawals'
-	if o42 = ssz.ReadOffset(buf[2741077:2741081]); o42 > size || o38 > o42 {
+	if o42 = ssz.ReadOffset(buf[2741293:2741297]); o42 > size || o38 > o42 {
 		return ssz.ErrOffset
 	}
 
 	// Field (43) 'LatestBlockHash'
 	if cap(b.LatestBlockHash) == 0 {
-		b.LatestBlockHash = make([]byte, 0, len(buf[2741081:2741113]))
+		b.LatestBlockHash = make([]byte, 0, len(buf[2741297:2741329]))
 	}
-	b.LatestBlockHash = append(b.LatestBlockHash, buf[2741081:2741113]...)
+	b.LatestBlockHash = append(b.LatestBlockHash, buf[2741297:2741329]...)
 
 	// Offset (44) 'PayloadExpectedWithdrawals'
-	if o44 = ssz.ReadOffset(buf[2741113:2741117]); o44 > size || o42 > o44 {
+	if o44 = ssz.ReadOffset(buf[2741329:2741333]); o44 > size || o42 > o44 {
 		return ssz.ErrOffset
 	}
 
@@ -2297,7 +2204,7 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 
 	// Field (21) 'InactivityScores'
 	{
-		buf = tail[o21:o24]
+		buf = tail[o21:o27]
 		num, err := ssz.DivideInt2(len(buf), 8, 1099511627776)
 		if err != nil {
 			return err
@@ -2308,17 +2215,6 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 		}
 	}
 
-	// Field (24) 'LatestExecutionPayloadBid'
-	{
-		buf = tail[o24:o27]
-		if b.LatestExecutionPayloadBid == nil {
-			b.LatestExecutionPayloadBid = new(ExecutionPayloadBid)
-		}
-		if err = b.LatestExecutionPayloadBid.UnmarshalSSZ(buf); err != nil {
-			return err
-		}
-	}
-
 	// Field (27) 'HistoricalSummaries'
 	{
 		buf = tail[o27:o34]
@@ -2449,7 +2345,7 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 
 // SizeSSZ returns the ssz encoded size in bytes for the BeaconStateGloas object
 func (b *BeaconStateGloas) SizeSSZ() (size int) {
-	size = 2741117
+	size = 2741333
 
 	// Field (7) 'HistoricalRoots'
 	size += len(b.HistoricalRoots) * 32
@@ -2472,12 +2368,6 @@ func (b *BeaconStateGloas) SizeSSZ() (size int) {
 	// Field (21) 'InactivityScores'
 	size += len(b.InactivityScores) * 8
 
-	// Field (24) 'LatestExecutionPayloadBid'
-	if b.LatestExecutionPayloadBid == nil {
-		b.LatestExecutionPayloadBid = new(ExecutionPayloadBid)
-	}
-	size += b.LatestExecutionPayloadBid.SizeSSZ()
-
 	// Field (27) 'HistoricalSummaries'
 	size += len(b.HistoricalSummaries) * 64
 
@@ -3359,7 +3249,7 @@ func (e *ExecutionPayloadEnvelope) MarshalSSZ() ([]byte, error) {
 // MarshalSSZTo ssz marshals the ExecutionPayloadEnvelope object to a target array
 func (e *ExecutionPayloadEnvelope) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	dst = buf
-	offset := int(88)
+	offset := int(92)
 
 	// Offset (0) 'Payload'
 	dst = ssz.WriteOffset(dst, offset)
@@ -3388,7 +3278,11 @@ func (e *ExecutionPayloadEnvelope) MarshalSSZTo(buf []byte) (dst []byte, err err
 	// Field (4) 'Slot'
 	dst = ssz.MarshalUint64(dst, uint64(e.Slot))
 
-	// Field (5) 'StateRoot'
+	// Offset (5) 'BlobKzgCommitments'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(e.BlobKzgCommitments) * 48
+
+	// Field (6) 'StateRoot'
 	if size := len(e.StateRoot); size != 32 {
 		err = ssz.ErrBytesLengthFn("--.StateRoot", size, 32)
 		return
@@ -3405,6 +3299,19 @@ func (e *ExecutionPayloadEnvelope) MarshalSSZTo(buf []byte) (dst []byte, err err
 		return
 	}
 
+	// Field (5) 'BlobKzgCommitments'
+	if size := len(e.BlobKzgCommitments); size > 4096 {
+		err = ssz.ErrListTooBigFn("--.BlobKzgCommitments", size, 4096)
+		return
+	}
+	for ii := 0; ii < len(e.BlobKzgCommitments); ii++ {
+		if size := len(e.BlobKzgCommitments[ii]); size != 48 {
+			err = ssz.ErrBytesLengthFn("--.BlobKzgCommitments[ii]", size, 48)
+			return
+		}
+		dst = append(dst, e.BlobKzgCommitments[ii]...)
+	}
+
 	return
 }
 
@@ -3412,19 +3319,19 @@ func (e *ExecutionPayloadEnvelope) MarshalSSZTo(buf []byte) (dst []byte, err err
 func (e *ExecutionPayloadEnvelope) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size < 88 {
+	if size < 92 {
 		return ssz.ErrSize
 	}
 
 	tail := buf
-	var o0, o1 uint64
+	var o0, o1, o5 uint64
 
 	// Offset (0) 'Payload'
 	if o0 = ssz.ReadOffset(buf[0:4]); o0 > size {
 		return ssz.ErrOffset
 	}
 
-	if o0 != 88 {
+	if o0 != 92 {
 		return ssz.ErrInvalidVariableOffset
 	}
 
@@ -3445,11 +3352,16 @@ func (e *ExecutionPayloadEnvelope) UnmarshalSSZ(buf []byte) error {
 	// Field (4) 'Slot'
 	e.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[48:56]))
 
-	// Field (5) 'StateRoot'
-	if cap(e.StateRoot) == 0 {
-		e.StateRoot = make([]byte, 0, len(buf[56:88]))
+	// Offset (5) 'BlobKzgCommitments'
+	if o5 = ssz.ReadOffset(buf[56:60]); o5 > size || o1 > o5 {
+		return ssz.ErrOffset
 	}
-	e.StateRoot = append(e.StateRoot, buf[56:88]...)
+
+	// Field (6) 'StateRoot'
+	if cap(e.StateRoot) == 0 {
+		e.StateRoot = make([]byte, 0, len(buf[60:92]))
+	}
+	e.StateRoot = append(e.StateRoot, buf[60:92]...)
 
 	// Field (0) 'Payload'
 	{
@@ -3464,7 +3376,7 @@ func (e *ExecutionPayloadEnvelope) UnmarshalSSZ(buf []byte) error {
 
 	// Field (1) 'ExecutionRequests'
 	{
-		buf = tail[o1:]
+		buf = tail[o1:o5]
 		if e.ExecutionRequests == nil {
 			e.ExecutionRequests = new(v1.ExecutionRequests)
 		}
@@ -3472,12 +3384,28 @@ func (e *ExecutionPayloadEnvelope) UnmarshalSSZ(buf []byte) error {
 			return err
 		}
 	}
+
+	// Field (5) 'BlobKzgCommitments'
+	{
+		buf = tail[o5:]
+		num, err := ssz.DivideInt2(len(buf), 48, 4096)
+		if err != nil {
+			return err
+		}
+		e.BlobKzgCommitments = make([][]byte, num)
+		for ii := 0; ii < num; ii++ {
+			if cap(e.BlobKzgCommitments[ii]) == 0 {
+				e.BlobKzgCommitments[ii] = make([]byte, 0, len(buf[ii*48:(ii+1)*48]))
+			}
+			e.BlobKzgCommitments[ii] = append(e.BlobKzgCommitments[ii], buf[ii*48:(ii+1)*48]...)
+		}
+	}
 	return err
 }
 
 // SizeSSZ returns the ssz encoded size in bytes for the ExecutionPayloadEnvelope object
 func (e *ExecutionPayloadEnvelope) SizeSSZ() (size int) {
-	size = 88
+	size = 92
 
 	// Field (0) 'Payload'
 	if e.Payload == nil {
@@ -3491,6 +3419,9 @@ func (e *ExecutionPayloadEnvelope) SizeSSZ() (size int) {
 	}
 	size += e.ExecutionRequests.SizeSSZ()
 
+	// Field (5) 'BlobKzgCommitments'
+	size += len(e.BlobKzgCommitments) * 48
+
 	return
 }
 
@@ -3526,7 +3457,26 @@ func (e *ExecutionPayloadEnvelope) HashTreeRootWith(hh *ssz.Hasher) (err error)
 	// Field (4) 'Slot'
 	hh.PutUint64(uint64(e.Slot))
 
-	// Field (5) 'StateRoot'
+	// Field (5) 'BlobKzgCommitments'
+	{
+		if size := len(e.BlobKzgCommitments); size > 4096 {
+			err = ssz.ErrListTooBigFn("--.BlobKzgCommitments", size, 4096)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range e.BlobKzgCommitments {
+			if len(i) != 48 {
+				err = ssz.ErrBytesLength
+				return
+			}
+			hh.PutBytes(i)
+		}
+
+		numItems := uint64(len(e.BlobKzgCommitments))
+		hh.MerkleizeWithMixin(subIndx, numItems, 4096)
+	}
+
+	// Field (6) 'StateRoot'
 	if size := len(e.StateRoot); size != 32 {
 		err = ssz.ErrBytesLengthFn("--.StateRoot", size, 32)
 		return

proto/prysm/v1alpha1/gloas_test.go

@@ -33,7 +33,7 @@ func TestExecutionPayloadBid_Copy(t *testing.T) {
 				Slot:                   primitives.Slot(12345),
 				ExecutionPayment:       5645654,
 				Value:                  1000000000000000000,
-				BlobKzgCommitments:     [][]byte{[]byte("blob_kzg_commitments_48_bytes_longer_than_needed")},
+				BlobKzgCommitmentsRoot: []byte("blob_kzg_commitments_32_bytes!!"),
 			},
 		},
 	}

proto/prysm/v1alpha1/health.pb.go

@@ -8,6 +8,9 @@ package eth
 
 import (
 	context "context"
+	reflect "reflect"
+	sync "sync"
+
 	_ "google.golang.org/genproto/googleapis/api/annotations"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
@@ -15,8 +18,6 @@ import (
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/light_client.pb.go

@@ -7,13 +7,14 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	v1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/node.pb.go

@@ -8,6 +8,9 @@ package eth
 
 import (
 	context "context"
+	reflect "reflect"
+	sync "sync"
+
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	_ "google.golang.org/genproto/googleapis/api/annotations"
 	grpc "google.golang.org/grpc"
@@ -17,8 +20,6 @@ import (
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
 	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/p2p_messages.pb.go

@@ -7,14 +7,15 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_go_bitfield "github.com/OffchainLabs/go-bitfield"
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	_ "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/powchain.pb.go

@@ -7,12 +7,13 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	_ "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/slasher.pb.go

@@ -7,12 +7,13 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/sync_committee.pb.go

@@ -7,13 +7,14 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_go_bitfield "github.com/OffchainLabs/go-bitfield"
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/validator-client/keymanager.pb.go

@@ -7,14 +7,15 @@
 package validatorpb
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	github_com_OffchainLabs_prysm_v7_consensus_types_validator "github.com/OffchainLabs/prysm/v7/consensus-types/validator"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	v1alpha1 "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/validator.pb.go

@@ -8,6 +8,9 @@ package eth
 
 import (
 	context "context"
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	_ "google.golang.org/genproto/googleapis/api/annotations"
@@ -18,8 +21,6 @@ import (
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
 	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/withdrawals.pb.go

@@ -7,12 +7,13 @@
 package eth
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/ssz_query/response.pb.go

@@ -7,11 +7,12 @@
 package ssz_query
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

proto/ssz_query/testing/test_containers.pb.go

@@ -7,12 +7,13 @@
 package testing
 
 import (
+	reflect "reflect"
+	sync "sync"
+
 	github_com_OffchainLabs_go_bitfield "github.com/OffchainLabs/go-bitfield"
 	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
 )
 
 const (

testing/spectest/mainnet/BUILD.bazel

@@ -201,9 +201,9 @@ go_test(
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
+        "gloas__operations__attestation_test.go",
         "gloas__operations__execution_payload_header_test.go",
         "gloas__operations__proposer_slashing_test.go",
-        "gloas__operations__withdrawals_test.go",
         "gloas__sanity__slots_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",

testing/spectest/mainnet/gloas__operations__attestation_test.go

@@ -6,6 +6,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
 )
 
-func TestMainnet_Gloas_Operations_Withdrawals(t *testing.T) {
-	operations.RunWithdrawalsTest(t, "mainnet")
+func TestMainnet_Gloas_Operations_Attestation(t *testing.T) {
+	operations.RunAttestationTest(t, "mainnet")
 }

testing/spectest/minimal/BUILD.bazel

@@ -207,9 +207,9 @@ go_test(
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
+        "gloas__operations__attestation_test.go",
         "gloas__operations__execution_payload_bid_test.go",
         "gloas__operations__proposer_slashing_test.go",
-        "gloas__operations__withdrawals_test.go",
         "gloas__sanity__slots_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",

testing/spectest/minimal/gloas__operations__attestation_test.go

@@ -6,6 +6,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
 )
 
-func TestMinimal_Gloas_Operations_Withdrawals(t *testing.T) {
-	operations.RunWithdrawalsTest(t, "minimal")
+func TestMinimal_Gloas_Operations_Attestation(t *testing.T) {
+	operations.RunAttestationTest(t, "minimal")
 }

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

@@ -4,23 +4,21 @@ go_library(
     name = "go_default_library",
     testonly = True,
     srcs = [
+        "attestation.go",
         "execution_payload_bid.go",
         "helpers.go",
         "proposer_slashing.go",
-        "withdrawals.go",
     ],
     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/altair:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
-        "//testing/require:go_default_library",
         "//testing/spectest/shared/common/operations:go_default_library",
-        "//testing/spectest/utils:go_default_library",
     ],
 )

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

@@ -0,0 +1,26 @@
+package operations
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/altair"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	common "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/common/operations"
+)
+
+func blockWithAttestation(attestationSSZ []byte) (interfaces.SignedBeaconBlock, error) {
+	att := &ethpb.AttestationElectra{}
+	if err := att.UnmarshalSSZ(attestationSSZ); err != nil {
+		return nil, err
+	}
+	b := &ethpb.BeaconBlockGloas{}
+	b.Body = &ethpb.BeaconBlockBodyGloas{Attestations: []*ethpb.AttestationElectra{att}}
+	return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockGloas{Block: b})
+}
+
+func RunAttestationTest(t *testing.T, config string) {
+	common.RunAttestationTest(t, config, version.String(version.Gloas), blockWithAttestation, altair.ProcessAttestationsNoVerifySignature, sszToState)
+}

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

@@ -1,48 +0,0 @@
-package operations
-
-import (
-	"context"
-	"path"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"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"
-	common "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/common/operations"
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/utils"
-)
-
-func emptyBlockGloas() (interfaces.SignedBeaconBlock, error) {
-	b := &ethpb.SignedBeaconBlockGloas{
-		Block: &ethpb.BeaconBlockGloas{
-			Body: &ethpb.BeaconBlockBodyGloas{},
-		},
-	}
-	return blocks.NewSignedBeaconBlock(b)
-}
-
-func RunWithdrawalsTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, version.String(version.Gloas), "operations/withdrawals/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, version.String(version.Gloas), "operations/withdrawals/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			blk, err := emptyBlockGloas()
-			require.NoError(t, err)
-
-			common.RunBlockOperationTest(t, folderPath, blk, sszToState, func(_ context.Context, s state.BeaconState, _ interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				if err := gloas.ProcessWithdrawals(s); err != nil {
-					return nil, err
-				}
-				return s, nil
-			})
-		})
-	}
-}

testing/util/state.go

@@ -564,7 +564,7 @@ func NewBeaconStateGloas(options ...func(state *ethpb.BeaconStateGloas) error) (
 			BlockHash:              make([]byte, 32),
 			PrevRandao:             make([]byte, 32),
 			FeeRecipient:           make([]byte, 20),
-			BlobKzgCommitments:     [][]byte{make([]byte, 48)},
+			BlobKzgCommitmentsRoot: make([]byte, 32),
 		},
 		Builders:                     make([]*ethpb.Builder, 0),
 		ExecutionPayloadAvailability: make([]byte, 1024),