Move kzg commitments to bid

This refactors `ExpectedWithdrawals` to use shared helpers for pending
partial withdrawals and the validator sweep. The goal is to keep the
logic spec-aligned while making it easier to reuse across future forks.
```
**Example (Gloas expected withdrawals order):**
builder withdrawals
pending partial withdrawals
builder sweep withdrawals
validator sweep withdrawals
```

Note to reviewers: the helpers take a `*[]*enginev1.Withdrawal` so we
can append efficiently without returning/re-appending slices.

beacon-chain/core/gloas/BUILD.bazel

@@ -4,8 +4,10 @@ go_library(
     name = "go_default_library",
     srcs = [
         "bid.go",
+        "builder.go",
         "pending_payment.go",
         "proposer_slashing.go",
+        "withdrawal.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
     visibility = ["//visibility:public"],

beacon-chain/core/gloas/bid_test.go

@@ -203,7 +203,7 @@ func TestProcessExecutionPayloadBid_SelfBuildSuccess(t *testing.T) {
 		Slot:                   slot,
 		Value:                  0,
 		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
+		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xEE}, 48)},
 		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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
+		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xCC}, 48)},
 		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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
+		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xEE}, 48)},
 		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
 	}
 
@@ -350,7 +350,7 @@ func TestProcessExecutionPayloadBid_BuilderNotActive(t *testing.T) {
 		Slot:                   slot,
 		Value:                  10,
 		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x05}, 32),
+		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0x05}, 48)},
 		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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
+		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xEE}, 48)},
 		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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
+		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xEE}, 48)},
 		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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
+		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0xCC}, 48)},
 		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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
+		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0x44}, 48)},
 		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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
+		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0x44}, 48)},
 		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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
+		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0x44}, 48)},
 		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())

beacon-chain/core/gloas/builder.go

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,117 @@
+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),
-			BlobKzgCommitmentsRoot: make([]byte, 32),
+			BlobKzgCommitments:     [][]byte{make([]byte, 48)},
 		},
 		Eth1Data: &ethpb.Eth1Data{
 			DepositRoot: make([]byte, 32),

beacon-chain/state/interfaces_gloas.go

@@ -3,6 +3,7 @@ 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"
 )
 
@@ -13,6 +14,11 @@ type writeOnlyGloasFields interface {
 	RotateBuilderPendingPayments() error
 	AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal) error
 	UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val byte) error
+
+	SetPayloadExpectedWithdrawals(withdrawals []*enginev1.Withdrawal) error
+	DequeueBuilderPendingWithdrawals(num uint64) error
+	SetNextWithdrawalBuilderIndex(idx primitives.BuilderIndex) error
+	DecreaseBuilderBalance(builderIndex primitives.BuilderIndex, amount uint64) error
 }
 
 type readOnlyGloasFields interface {
@@ -21,4 +27,7 @@ type readOnlyGloasFields interface {
 	CanBuilderCoverBid(primitives.BuilderIndex, primitives.Gwei) (bool, error)
 	LatestBlockHash() ([32]byte, error)
 	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
+
+	IsParentBlockFull() (bool, error)
+	ExpectedWithdrawalsGloas() ([]*enginev1.Withdrawal, uint64, uint64, primitives.BuilderIndex, error)
 }

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

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

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

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

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

@@ -44,6 +44,56 @@ 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)
+	})
+
+	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),
+		})
+		require.NoError(t, err)
+
+		full, err := st.IsParentBlockFull()
+		require.NoError(t, err)
+		require.Equal(t, false, full)
+	})
+
+	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,
+			},
+		})
+		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,
+			},
+		})
+		require.NoError(t, err)
+
+		full, err := st.IsParentBlockFull()
+		require.NoError(t, err)
+		require.Equal(t, false, full)
+	})
+}
+
 func TestBuilderPubkey(t *testing.T) {
 	t.Run("returns error before gloas", func(t *testing.T) {
 		stIface, _ := util.DeterministicGenesisState(t, 1)

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

@@ -0,0 +1,167 @@
+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,77 +113,111 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, uint64, err
 	defer b.lock.RUnlock()
 
 	withdrawals := make([]*enginev1.Withdrawal, 0, params.BeaconConfig().MaxWithdrawalsPerPayload)
-	validatorIndex := b.nextWithdrawalValidatorIndex
 	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++
-		}
+	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()
+	epoch := slots.ToEpoch(b.slot)
 	bound := min(uint64(validatorsLen), params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
 	for range bound {
 		val, err := b.validatorAtIndexReadOnly(validatorIndex)
 		if err != nil {
-			return nil, 0, errors.Wrapf(err, "could not retrieve validator at index %d", validatorIndex)
+			return errors.Wrapf(err, "could not retrieve validator at index %d", validatorIndex)
 		}
 		balance, err := b.balanceAtIndex(validatorIndex)
 		if err != nil {
-			return nil, 0, errors.Wrapf(err, "could not retrieve balance at index %d", validatorIndex)
+			return errors.Wrapf(err, "could not retrieve balance at index %d", validatorIndex)
 		}
 		if b.version >= version.Electra {
 			var partiallyWithdrawnBalance uint64
-			for _, w := range withdrawals {
+			for _, w := range ws {
 				if w.ValidatorIndex == validatorIndex {
 					partiallyWithdrawnBalance += w.Amount
 				}
 			}
 			balance, err = mathutil.Sub64(balance, partiallyWithdrawnBalance)
 			if err != nil {
-				return nil, 0, errors.Wrapf(err, "could not subtract balance %d with partial withdrawn balance %d", balance, partiallyWithdrawnBalance)
+				return errors.Wrapf(err, "could not subtract balance %d with partial withdrawn balance %d", balance, partiallyWithdrawnBalance)
 			}
 		}
 		if helpers.IsFullyWithdrawableValidator(val, balance, epoch, b.version) {
-			withdrawals = append(withdrawals, &enginev1.Withdrawal{
+			ws = append(ws, &enginev1.Withdrawal{
 				Index:          withdrawalIndex,
 				ValidatorIndex: validatorIndex,
 				Address:        bytesutil.SafeCopyBytes(val.GetWithdrawalCredentials()[ETH1AddressOffset:]),
@@ -191,7 +225,7 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, uint64, err
 			})
 			withdrawalIndex++
 		} else if helpers.IsPartiallyWithdrawableValidator(val, balance, epoch, b.version) {
-			withdrawals = append(withdrawals, &enginev1.Withdrawal{
+			ws = append(ws, &enginev1.Withdrawal{
 				Index:          withdrawalIndex,
 				ValidatorIndex: validatorIndex,
 				Address:        bytesutil.SafeCopyBytes(val.GetWithdrawalCredentials()[ETH1AddressOffset:]),
@@ -199,7 +233,7 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, uint64, err
 			})
 			withdrawalIndex++
 		}
-		if uint64(len(withdrawals)) == params.BeaconConfig().MaxWithdrawalsPerPayload {
+		if uint64(len(ws)) == params.BeaconConfig().MaxWithdrawalsPerPayload {
 			break
 		}
 		validatorIndex += 1
@@ -208,7 +242,8 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, uint64, err
 		}
 	}
 
-	return withdrawals, processedPartialWithdrawalsCount, nil
+	*withdrawals = ws
+	return nil
 }
 
 func (b *BeaconState) PendingPartialWithdrawals() ([]*ethpb.PendingPartialWithdrawal, error) {

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

@@ -1,6 +1,7 @@
 package state_native
 
 import (
+	"errors"
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
@@ -8,10 +9,27 @@ 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"
 )
 
+// 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)]
@@ -69,6 +87,38 @@ 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 {
@@ -82,7 +132,7 @@ func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid)
 	parentBlockRoot := h.ParentBlockRoot()
 	blockHash := h.BlockHash()
 	randao := h.PrevRandao()
-	blobKzgCommitmentsRoot := h.BlobKzgCommitmentsRoot()
+	blobKzgCommitments := bytesutil.SafeCopy2dBytes(h.BlobKzgCommitments())
 	feeRecipient := h.FeeRecipient()
 	b.latestExecutionPayloadBid = &ethpb.ExecutionPayloadBid{
 		ParentBlockHash:        parentBlockHash[:],
@@ -94,7 +144,7 @@ func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid)
 		Slot:                   h.Slot(),
 		Value:                  h.Value(),
 		ExecutionPayment:       h.ExecutionPayment(),
-		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot[:],
+		BlobKzgCommitments:     blobKzgCommitments,
 		FeeRecipient:           feeRecipient[:],
 	}
 	b.markFieldAsDirty(types.LatestExecutionPayloadBid)
@@ -161,3 +211,65 @@ func (b *BeaconState) UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val
 	b.markFieldAsDirty(types.ExecutionPayloadAvailability)
 	return nil
 }
+
+// SetNextWithdrawalBuilderIndex sets the next builder index for the withdrawals sweep.
+func (b *BeaconState) SetNextWithdrawalBuilderIndex(index primitives.BuilderIndex) error {
+	if b.version < version.Gloas {
+		return errNotSupported("SetNextWithdrawalBuilderIndex", b.version)
+	}
+
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	b.nextWithdrawalBuilderIndex = index
+	b.markFieldAsDirty(types.NextWithdrawalBuilderIndex)
+	return nil
+}
+
+// DecreaseBuilderBalance decreases the builder's balance by amount (saturating at 0).
+func (b *BeaconState) DecreaseBuilderBalance(builderIndex primitives.BuilderIndex, amount uint64) error {
+	if b.version < version.Gloas {
+		return errNotSupported("DecreaseBuilderBalance", b.version)
+	}
+	if amount == 0 {
+		return nil
+	}
+
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	idx := uint64(builderIndex)
+	if idx >= uint64(len(b.builders)) {
+		return fmt.Errorf("builder index %d out of range (len=%d)", builderIndex, len(b.builders))
+	}
+
+	// Copy-on-write for shared builders registry.
+	if b.sharedFieldReferences[types.Builders].Refs() > 1 {
+		builders := make([]*ethpb.Builder, len(b.builders))
+		copy(builders, b.builders)
+		b.builders = builders
+		b.sharedFieldReferences[types.Builders].MinusRef()
+		b.sharedFieldReferences[types.Builders] = stateutil.NewRef(1)
+
+		// Ensure we don't mutate a shared builder pointer.
+		if b.builders[idx] != nil {
+			b.builders[idx] = ethpb.CopyBuilder(b.builders[idx])
+		}
+	}
+
+	builder := b.builders[idx]
+	if builder == nil {
+		return fmt.Errorf("builder at index %d is nil", builderIndex)
+	}
+
+	bal := uint64(builder.Balance)
+	if amount >= bal {
+		builder.Balance = 0
+	} else {
+		builder.Balance = primitives.Gwei(bal - amount)
+	}
+
+	b.markFieldAsDirty(types.Builders)
+	b.addDirtyIndices(types.Builders, []uint64{idx})
+	return nil
+}

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

@@ -8,6 +8,7 @@ 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"
@@ -18,7 +19,7 @@ type testExecutionPayloadBid struct {
 	parentBlockRoot        [32]byte
 	blockHash              [32]byte
 	prevRandao             [32]byte
-	blobKzgCommitmentsRoot [32]byte
+	blobKzgCommitments     [][]byte
 	feeRecipient           [20]byte
 	gasLimit               uint64
 	builderIndex           primitives.BuilderIndex
@@ -40,9 +41,9 @@ func (t testExecutionPayloadBid) Value() primitives.Gwei { return t.value }
 func (t testExecutionPayloadBid) ExecutionPayment() primitives.Gwei {
 	return t.executionPayment
 }
-func (t testExecutionPayloadBid) BlobKzgCommitmentsRoot() [32]byte { return t.blobKzgCommitmentsRoot }
-func (t testExecutionPayloadBid) FeeRecipient() [20]byte           { return t.feeRecipient }
-func (t testExecutionPayloadBid) IsNil() bool                      { return false }
+func (t testExecutionPayloadBid) BlobKzgCommitments() [][]byte { return t.blobKzgCommitments }
+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) {
@@ -57,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))
-			blobRoot        = [32]byte(bytes.Repeat([]byte{0x22}, 32))
+			blobCommitments = [][]byte{bytes.Repeat([]byte{0x22}, 48)}
 			feeRecipient    [20]byte
 		)
 		copy(feeRecipient[:], bytes.Repeat([]byte{0x33}, len(feeRecipient)))
@@ -70,7 +71,7 @@ func TestSetExecutionPayloadBid(t *testing.T) {
 			parentBlockRoot:        parentBlockRoot,
 			blockHash:              blockHash,
 			prevRandao:             prevRandao,
-			blobKzgCommitmentsRoot: blobRoot,
+			blobKzgCommitments:     blobCommitments,
 			feeRecipient:           feeRecipient,
 			gasLimit:               123,
 			builderIndex:           7,
@@ -86,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, blobRoot[:], st.latestExecutionPayloadBid.BlobKzgCommitmentsRoot)
+		require.DeepEqual(t, blobCommitments, st.latestExecutionPayloadBid.BlobKzgCommitments)
 		require.DeepEqual(t, feeRecipient[:], st.latestExecutionPayloadBid.FeeRecipient)
 		require.Equal(t, uint64(123), st.latestExecutionPayloadBid.GasLimit)
 		require.Equal(t, primitives.BuilderIndex(7), st.latestExecutionPayloadBid.BuilderIndex)
@@ -229,6 +230,163 @@ 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),
@@ -318,6 +476,61 @@ func TestUpdateExecutionPayloadAvailabilityAtIndex_OutOfRange(t *testing.T) {
 	}
 }
 
+func TestDecreaseBuilderBalance(t *testing.T) {
+	t.Run("previous fork returns expected error", func(t *testing.T) {
+		st := &BeaconState{version: version.Fulu}
+		err := st.DecreaseBuilderBalance(0, 1)
+		require.ErrorContains(t, "DecreaseBuilderBalance", err)
+	})
+
+	t.Run("decreases and saturates", func(t *testing.T) {
+		st := &BeaconState{
+			version:      version.Gloas,
+			dirtyFields:  make(map[types.FieldIndex]bool),
+			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},
+			},
+		}
+
+		require.NoError(t, st.DecreaseBuilderBalance(0, 3))
+		require.Equal(t, uint64(7), uint64(st.builders[0].Balance))
+		require.Equal(t, true, st.dirtyFields[types.Builders])
+
+		require.NoError(t, st.DecreaseBuilderBalance(0, 100))
+		require.Equal(t, uint64(0), uint64(st.builders[0].Balance))
+	})
+
+	t.Run("copy-on-write preserves shared state", func(t *testing.T) {
+		sharedRef := stateutil.NewRef(2)
+		sharedBuilders := []*ethpb.Builder{
+			{Balance: 10},
+		}
+
+		st1 := &BeaconState{
+			version:      version.Gloas,
+			dirtyFields:  make(map[types.FieldIndex]bool),
+			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))
+	})
+}
+
 func newGloasStateWithAvailability(t *testing.T, availability []byte) *BeaconState {
 	t.Helper()
 

changelog/terencechain_refactor-expected-withdrawals.md

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

config/params/config.go

@@ -47,6 +47,7 @@ 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).
@@ -126,6 +127,7 @@ 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,6 +194,8 @@ 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,6 +83,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	HysteresisQuotient:             4,
 	HysteresisDownwardMultiplier:   1,
 	HysteresisUpwardMultiplier:     5,
+	BuilderIndexFlag:               1099511627776,
 
 	// Gwei value constants.
 	MinDepositAmount:          1 * 1e9,
@@ -169,6 +170,7 @@ 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,6 +49,7 @@ 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)
@@ -94,6 +95,7 @@ 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),
-				BlobKzgCommitmentsRoot: make([]byte, fieldparams.RootLength),
+				BlobKzgCommitments:     [][]byte{make([]byte, fieldparams.BLSPubkeyLength)},
 			},
 			Signature: make([]byte, fieldparams.BLSSignatureLength),
 		},

consensus-types/blocks/signed_execution_bid.go

@@ -1,6 +1,7 @@
 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"
@@ -43,11 +44,17 @@ func (h executionPayloadBidGloas) IsNil() bool {
 		len(h.payload.ParentBlockRoot) != 32 ||
 		len(h.payload.BlockHash) != 32 ||
 		len(h.payload.PrevRandao) != 32 ||
-		len(h.payload.BlobKzgCommitmentsRoot) != 32 ||
+		len(h.payload.BlobKzgCommitments) > field_params.MaxBlobCommitmentsPerBlock ||
 		len(h.payload.FeeRecipient) != 20 {
 		return true
 	}
 
+	for _, commitment := range h.payload.BlobKzgCommitments {
+		if len(commitment) != 48 {
+			return true
+		}
+	}
+
 	return false
 }
 
@@ -131,9 +138,9 @@ func (h executionPayloadBidGloas) ExecutionPayment() primitives.Gwei {
 	return primitives.Gwei(h.payload.ExecutionPayment)
 }
 
-// BlobKzgCommitmentsRoot returns the root of the KZG commitments for blobs.
-func (h executionPayloadBidGloas) BlobKzgCommitmentsRoot() [32]byte {
-	return [32]byte(h.payload.BlobKzgCommitmentsRoot)
+// BlobKzgCommitments returns the KZG commitments for blobs.
+func (h executionPayloadBidGloas) BlobKzgCommitments() [][]byte {
+	return h.payload.BlobKzgCommitments
 }
 
 // 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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x05}, 32),
+		BlobKzgCommitments:     [][]byte{bytes.Repeat([]byte{0x05}, 48)},
 		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 root",
-				mutate: func(b *ethpb.ExecutionPayloadBid) { b.BlobKzgCommitmentsRoot = []byte{0x05} },
+				name:   "blob kzg commitments length",
+				mutate: func(b *ethpb.ExecutionPayloadBid) { b.BlobKzgCommitments = [][]byte{[]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, [32]byte(bytes.Repeat([]byte{0x05}, 32)), wrapped.BlobKzgCommitmentsRoot())
+		assert.DeepEqual(t, [][]byte{bytes.Repeat([]byte{0x05}, 48)}, wrapped.BlobKzgCommitments())
 		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
-	BlobKzgCommitmentsRoot() [32]byte
+	BlobKzgCommitments() [][]byte
 	FeeRecipient() [20]byte
 	IsNil() bool
 }

consensus-types/primitives/builder_index.go

@@ -13,6 +13,15 @@ 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,9 +10,32 @@ 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,3 +33,32 @@ 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,11 +7,10 @@
 package dbval
 
 import (
-	reflect "reflect"
-	sync "sync"
-
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
 )
 
 const (

proto/engine/v1/electra.pb.go

@@ -7,12 +7,11 @@
 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,13 +7,12 @@
 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,11 +7,10 @@
 package enginev1
 
 import (
-	reflect "reflect"
-	sync "sync"
-
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
 )
 
 const (

proto/eth/ext/options.pb.go

@@ -7,11 +7,10 @@
 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,15 +7,14 @@
 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,15 +7,14 @@
 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,12 +7,11 @@
 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,14 +7,13 @@
 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,12 +7,11 @@
 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,14 +7,13 @@
 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,14 +7,13 @@
 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,14 +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"
 	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,9 +8,6 @@ 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"
@@ -20,6 +17,8 @@ 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,14 +7,13 @@
 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,15 +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"
 	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,13 +7,12 @@
 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,12 +147,14 @@ 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,
-			BlobKzgCommitmentsRoot: bytesutil.SafeCopyBytes(header.Message.BlobKzgCommitmentsRoot),
+			ExecutionPayment:       header.Message.ExecutionPayment,
+			BlobKzgCommitments:     bytesutil.SafeCopy2dBytes(header.Message.BlobKzgCommitments),
 		}
 	}
 	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()),
-		BlobKzgCommitmentsRoot: bytes(32),
+		BlobKzgCommitments:     [][]byte{bytes(48)},
 	}
 }
 

proto/prysm/v1alpha1/data_columns.pb.go

@@ -7,12 +7,11 @@
 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,9 +8,6 @@ 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"
@@ -20,6 +17,8 @@ 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,13 +7,12 @@
 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,11 +7,10 @@
 package eth
 
 import (
-	reflect "reflect"
-	sync "sync"
-
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/gloas.go

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

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

proto/prysm/v1alpha1/health.pb.go

@@ -8,9 +8,6 @@ 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"
@@ -18,6 +15,8 @@ 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,14 +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"
 	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,9 +8,6 @@ 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"
@@ -20,6 +17,8 @@ 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,15 +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"
 	_ "google.golang.org/protobuf/types/descriptorpb"
+	reflect "reflect"
+	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/powchain.pb.go

@@ -7,13 +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"
 	_ "google.golang.org/protobuf/types/descriptorpb"
+	reflect "reflect"
+	sync "sync"
 )
 
 const (

proto/prysm/v1alpha1/slasher.pb.go

@@ -7,13 +7,12 @@
 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,14 +7,13 @@
 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,15 +7,14 @@
 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,9 +8,6 @@ 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"
@@ -21,6 +18,8 @@ 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,13 +7,12 @@
 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,12 +7,11 @@
 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,13 +7,12 @@
 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

@@ -203,6 +203,7 @@ go_test(
         "gloas__epoch_processing__process_builder_pending_payments_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__withdrawals_test.go

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

testing/spectest/minimal/BUILD.bazel

@@ -209,6 +209,7 @@ go_test(
         "gloas__epoch_processing__process_builder_pending_payments_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__withdrawals_test.go

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

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

@@ -7,16 +7,20 @@ go_library(
         "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/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/withdrawals.go

@@ -0,0 +1,48 @@
+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),
-			BlobKzgCommitmentsRoot: make([]byte, 32),
+			BlobKzgCommitments:     [][]byte{make([]byte, 48)},
 		},
 		Builders:                     make([]*ethpb.Builder, 0),
 		ExecutionPayloadAvailability: make([]byte, 1024),