Merge branch 'develop' into calculate-post-state

beacon-chain/core/peerdas/validator.go

@@ -73,22 +73,23 @@ func PopulateFromSidecar(sidecar blocks.VerifiedRODataColumn) *SidecarReconstruc
 
 // ValidatorsCustodyRequirement returns the number of custody groups regarding the validator indices attached to the beacon node.
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#validator-custody
-func ValidatorsCustodyRequirement(st beaconState.ReadOnlyBalances, validatorsIndex map[primitives.ValidatorIndex]bool) (uint64, error) {
-	cfg := params.BeaconConfig()
-	idxs := make([]primitives.ValidatorIndex, 0, len(validatorsIndex))
+func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validatorsIndex map[primitives.ValidatorIndex]bool) (uint64, error) {
+	totalNodeBalance := uint64(0)
 	for index := range validatorsIndex {
-		idxs = append(idxs, index)
-	}
-	totalBalance, err := st.EffectiveBalanceSum(idxs)
-	if err != nil {
-		return 0, errors.Wrap(err, "effective balances")
+		validator, err := state.ValidatorAtIndexReadOnly(index)
+		if err != nil {
+			return 0, errors.Wrapf(err, "validator at index %v", index)
+		}
+
+		totalNodeBalance += validator.EffectiveBalance()
 	}
 
+	cfg := params.BeaconConfig()
 	numberOfCustodyGroups := cfg.NumberOfCustodyGroups
 	validatorCustodyRequirement := cfg.ValidatorCustodyRequirement
 	balancePerAdditionalCustodyGroup := cfg.BalancePerAdditionalCustodyGroup
 
-	count := totalBalance / balancePerAdditionalCustodyGroup
+	count := totalNodeBalance / balancePerAdditionalCustodyGroup
 	return min(max(count, validatorCustodyRequirement), numberOfCustodyGroups), nil
 }
 

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -116,17 +116,32 @@ func CalculateStateRoot(
 	rollback state.BeaconState,
 	signed interfaces.ReadOnlySignedBeaconBlock,
 ) ([32]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "core.state.CalculateStateRoot")
+	st, err := CalculatePostState(ctx, rollback, signed)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	return st.HashTreeRoot(ctx)
+}
+
+// CalculatePostState returns the post-block state after processing the given
+// block on a copy of the input state. It is identical to CalculateStateRoot
+// but returns the full state instead of just its hash tree root.
+func CalculatePostState(
+	ctx context.Context,
+	rollback state.BeaconState,
+	signed interfaces.ReadOnlySignedBeaconBlock,
+) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "core.state.CalculatePostState")
 	defer span.End()
 	if ctx.Err() != nil {
 		tracing.AnnotateError(span, ctx.Err())
-		return [32]byte{}, ctx.Err()
+		return nil, ctx.Err()
 	}
 	if rollback == nil || rollback.IsNil() {
-		return [32]byte{}, errors.New("nil state")
+		return nil, errors.New("nil state")
 	}
 	if signed == nil || signed.IsNil() || signed.Block().IsNil() {
-		return [32]byte{}, errors.New("nil block")
+		return nil, errors.New("nil block")
 	}
 
 	// Copy state to avoid mutating the state reference.
@@ -137,22 +152,22 @@ func CalculateStateRoot(
 	parentRoot := signed.Block().ParentRoot()
 	state, err = ProcessSlotsUsingNextSlotCache(ctx, state, parentRoot[:], signed.Block().Slot())
 	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not process slots")
+		return nil, errors.Wrap(err, "could not process slots")
 	}
 
 	// Execute per block transition.
 	if features.Get().EnableProposerPreprocessing {
 		state, err = processBlockForProposing(ctx, state, signed)
 		if err != nil {
-			return [32]byte{}, errors.Wrap(err, "could not process block for proposing")
+			return nil, errors.Wrap(err, "could not process block for proposing")
 		}
 	} else {
 		state, err = ProcessBlockForStateRoot(ctx, state, signed)
 		if err != nil {
-			return [32]byte{}, errors.Wrap(err, "could not process block")
+			return nil, errors.Wrap(err, "could not process block")
 		}
 	}
-	return state.HashTreeRoot(ctx)
+	return state, nil
 }
 
 // processBlockVerifySigs processes the block and verifies the signatures within it. Block signatures are not verified as this block is not yet signed.

beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go

@@ -609,21 +609,31 @@ func (vs *Server) GetFeeRecipientByPubKey(ctx context.Context, request *ethpb.Fe
 // computeStateRoot computes the state root after a block has been processed through a state transition and
 // returns it to the validator client.
 func (vs *Server) computeStateRoot(ctx context.Context, block interfaces.SignedBeaconBlock) ([]byte, error) {
+	st, err := vs.computePostBlockState(ctx, block)
+	if err != nil {
+		return nil, err
+	}
+	root, err := st.HashTreeRoot(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute state root")
+	}
+	log.WithField("beaconStateRoot", fmt.Sprintf("%#x", root)).Debugf("Computed state root")
+	return root[:], nil
+}
+
+// computePostBlockState computes the post-block state by running the state transition.
+// It uses the same logic as CalculateStateRoot (Copy, feature flags, slot processing)
+// but returns the full state instead of just its hash.
+func (vs *Server) computePostBlockState(ctx context.Context, block interfaces.SignedBeaconBlock) (state.BeaconState, error) {
 	beaconState, err := vs.StateGen.StateByRoot(ctx, block.Block().ParentRoot())
 	if err != nil {
 		return nil, errors.Wrap(err, "could not retrieve beacon state")
 	}
-	root, err := transition.CalculateStateRoot(
-		ctx,
-		beaconState,
-		block,
-	)
+	st, err := transition.CalculatePostState(ctx, beaconState, block)
 	if err != nil {
-		return vs.handleStateRootError(ctx, block, err)
+		return vs.handlePostBlockStateError(ctx, block, err)
 	}
-
-	log.WithField("beaconStateRoot", fmt.Sprintf("%#x", root)).Debugf("Computed state root")
-	return root[:], nil
+	return st, nil
 }
 
 type computeStateRootAttemptsKeyType string
@@ -631,8 +641,8 @@ type computeStateRootAttemptsKeyType string
 const computeStateRootAttemptsKey = computeStateRootAttemptsKeyType("compute-state-root-attempts")
 const maxComputeStateRootAttempts = 3
 
-// handleStateRootError retries block construction in some error cases.
-func (vs *Server) handleStateRootError(ctx context.Context, block interfaces.SignedBeaconBlock, err error) ([]byte, error) {
+// handlePostBlockStateError retries block construction in some error cases.
+func (vs *Server) handlePostBlockStateError(ctx context.Context, block interfaces.SignedBeaconBlock, err error) (state.BeaconState, error) {
 	if ctx.Err() != nil {
 		return nil, status.Errorf(codes.Canceled, "context error: %v", ctx.Err())
 	}
@@ -681,8 +691,8 @@ func (vs *Server) handleStateRootError(ctx context.Context, block interfaces.Sig
 	} else {
 		ctx = context.WithValue(ctx, computeStateRootAttemptsKey, v+1)
 	}
-	// recursive call to compute state root again
-	return vs.computeStateRoot(ctx, block)
+	// recursive call to compute post-block state again
+	return vs.computePostBlockState(ctx, block)
 }
 
 // Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go

@@ -1313,8 +1313,8 @@ func TestProposer_ComputeStateRoot_OK(t *testing.T) {
 	require.NoError(t, err)
 }
 
-func TestHandleStateRootError_MaxAttemptsReached(t *testing.T) {
-	// Test that handleStateRootError returns an error when max attempts is reached
+func TestHandlePostBlockStateError_MaxAttemptsReached(t *testing.T) {
+	// Test that handlePostBlockStateError returns an error when max attempts is reached
 	// instead of recursing infinitely.
 	ctx := t.Context()
 	vs := &Server{}
@@ -1327,15 +1327,15 @@ func TestHandleStateRootError_MaxAttemptsReached(t *testing.T) {
 	// Pre-seed the context with max attempts already reached
 	ctx = context.WithValue(ctx, computeStateRootAttemptsKey, maxComputeStateRootAttempts)
 
-	// Call handleStateRootError with a retryable error
-	_, err = vs.handleStateRootError(ctx, wsb, transition.ErrAttestationsSignatureInvalid)
+	// Call handlePostBlockStateError with a retryable error
+	_, err = vs.handlePostBlockStateError(ctx, wsb, transition.ErrAttestationsSignatureInvalid)
 
 	// Should return an error about max attempts instead of recursing
 	require.ErrorContains(t, "attempted max compute state root attempts", err)
 }
 
-func TestHandleStateRootError_IncrementsAttempts(t *testing.T) {
-	// Test that handleStateRootError properly increments the attempts counter
+func TestHandlePostBlockStateError_IncrementsAttempts(t *testing.T) {
+	// Test that handlePostBlockStateError properly increments the attempts counter
 	// and eventually fails after max attempts.
 	db := dbutil.SetupDB(t)
 	ctx := t.Context()
@@ -1357,10 +1357,10 @@ func TestHandleStateRootError_IncrementsAttempts(t *testing.T) {
 	// Add a state for the parent root so StateByRoot succeeds
 	require.NoError(t, stateGen.SaveState(ctx, parentRoot, beaconState))
 
-	// Call handleStateRootError with a retryable error - it will recurse
-	// but eventually hit the max attempts limit since CalculateStateRoot
+	// Call handlePostBlockStateError with a retryable error - it will recurse
+	// but eventually hit the max attempts limit since CalculatePostState
 	// will keep failing (no valid attestations, randao, etc.)
-	_, err = vs.handleStateRootError(ctx, wsb, transition.ErrAttestationsSignatureInvalid)
+	_, err = vs.handlePostBlockStateError(ctx, wsb, transition.ErrAttestationsSignatureInvalid)
 
 	// Should eventually fail - either with max attempts or another error
 	require.NotNil(t, err)

beacon-chain/state/interfaces.go

@@ -152,7 +152,6 @@ type ReadOnlyBalances interface {
 	Balances() []uint64
 	BalanceAtIndex(idx primitives.ValidatorIndex) (uint64, error)
 	BalancesLength() int
-	EffectiveBalanceSum([]primitives.ValidatorIndex) (uint64, error)
 }
 
 // ReadOnlyCheckpoint defines a struct which only has read access to checkpoint methods.

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

@@ -8,7 +8,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/pkg/errors"
 )
 
 // Validators participating in consensus on the beacon chain.
@@ -81,25 +80,6 @@ func (b *BeaconState) ValidatorAtIndex(idx primitives.ValidatorIndex) (*ethpb.Va
 	return b.validatorAtIndex(idx)
 }
 
-// EffectiveBalances returns the sum of the effective balances of the given list of validator indices, the eb of each given validator, or an
-// error if one of the indices is out of bounds, or the state wasn't correctly initialized.
-func (b *BeaconState) EffectiveBalanceSum(idxs []primitives.ValidatorIndex) (uint64, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-	var sum uint64
-	for i := range idxs {
-		if b.validatorsMultiValue == nil {
-			return 0, errors.Wrap(state.ErrNilValidatorsInState, "nil validators multi-value slice")
-		}
-		v, err := b.validatorsMultiValue.At(b, uint64(idxs[i]))
-		if err != nil {
-			return 0, errors.Wrap(err, "validators multi value at index")
-		}
-		sum += v.EffectiveBalance
-	}
-	return sum, nil
-}
-
 func (b *BeaconState) validatorAtIndex(idx primitives.ValidatorIndex) (*ethpb.Validator, error) {
 	if b.validatorsMultiValue == nil {
 		return &ethpb.Validator{}, nil

beacon-chain/state/stategen/mock/mock.go

@@ -5,7 +5,6 @@ import (
 	"context"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stategen"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 )
 
@@ -15,8 +14,6 @@ type StateManager struct {
 	StatesBySlot map[primitives.Slot]state.BeaconState
 }
 
-var _ stategen.StateManager = (*StateManager)(nil)
-
 // NewService --
 func NewService() *StateManager {
 	return &StateManager{
@@ -104,8 +101,3 @@ func (m *StateManager) AddStateForSlot(state state.BeaconState, slot primitives.
 func (m *StateManager) DeleteStateFromCaches(context.Context, [32]byte) error {
 	return nil
 }
-
-// FinalizedReadOnlyBalances --
-func (m *StateManager) FinalizedReadOnlyBalances() stategen.NilCheckableReadOnlyBalances {
-	panic("unimplemented")
-}

beacon-chain/state/stategen/service.go

@@ -27,13 +27,6 @@ var defaultHotStateDBInterval primitives.Slot = 128
 
 var populatePubkeyCacheOnce sync.Once
 
-// NilCheckableReadOnlyBalances adds the IsNil method to ReadOnlyBalances
-// to allow checking if the underlying state value is nil.
-type NilCheckableReadOnlyBalances interface {
-	state.ReadOnlyBalances
-	IsNil() bool
-}
-
 // StateManager represents a management object that handles the internal
 // logic of maintaining both hot and cold states in DB.
 type StateManager interface {
@@ -50,7 +43,6 @@ type StateManager interface {
 	ActiveNonSlashedBalancesByRoot(context.Context, [32]byte) ([]uint64, error)
 	StateByRootIfCachedNoCopy(blockRoot [32]byte) state.BeaconState
 	StateByRootInitialSync(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
-	FinalizedReadOnlyBalances() NilCheckableReadOnlyBalances
 }
 
 // State is a concrete implementation of StateManager.
@@ -209,8 +201,3 @@ func (s *State) FinalizedState() state.BeaconState {
 	defer s.finalizedInfo.lock.RUnlock()
 	return s.finalizedInfo.state.Copy()
 }
-
-// Returns the finalized state as a ReadOnlyBalances so that it can be used read-only without copying.
-func (s *State) FinalizedReadOnlyBalances() NilCheckableReadOnlyBalances {
-	return s.finalizedInfo.state
-}

beacon-chain/sync/BUILD.bazel

@@ -54,7 +54,6 @@ go_library(
         "validate_aggregate_proof.go",
         "validate_attester_slashing.go",
         "validate_beacon_attestation.go",
-        "validate_beacon_block_gloas.go",
         "validate_beacon_blocks.go",
         "validate_blob.go",
         "validate_bls_to_execution_change.go",
@@ -212,7 +211,6 @@ go_test(
         "validate_aggregate_proof_test.go",
         "validate_attester_slashing_test.go",
         "validate_beacon_attestation_test.go",
-        "validate_beacon_block_gloas_test.go",
         "validate_beacon_blocks_test.go",
         "validate_blob_test.go",
         "validate_bls_to_execution_change_test.go",

beacon-chain/sync/custody.go

@@ -185,7 +185,7 @@ func (s *Service) validatorsCustodyRequirement() (uint64, error) {
 	}
 
 	// Retrieve the finalized state.
-	finalizedState := s.cfg.stateGen.FinalizedReadOnlyBalances()
+	finalizedState := s.cfg.stateGen.FinalizedState()
 	if finalizedState == nil || finalizedState.IsNil() {
 		return 0, nilFinalizedStateError
 	}

beacon-chain/sync/validate_beacon_attestation.go

@@ -268,23 +268,10 @@ func (s *Service) validateCommitteeIndexAndCount(
 	a eth.Att,
 	bs state.ReadOnlyBeaconState,
 ) (primitives.CommitteeIndex, uint64, pubsub.ValidationResult, error) {
-	// Validate committee index based on fork.
-	if a.Version() >= version.Electra {
-		data := a.GetData()
-		attEpoch := slots.ToEpoch(data.Slot)
-		postGloas := attEpoch >= params.BeaconConfig().GloasForkEpoch
-		if postGloas {
-			if result, err := s.validateGloasCommitteeIndex(data); result != pubsub.ValidationAccept {
-				return 0, 0, result, err
-			}
-		} else {
-			// [REJECT] attestation.data.index == 0 (New in Electra, removed in Gloas)
-			if data.CommitteeIndex != 0 {
-				return 0, 0, pubsub.ValidationReject, errors.New("attestation data's committee index must be 0")
-			}
-		}
+	// - [REJECT] attestation.data.index == 0
+	if a.Version() >= version.Electra && a.GetData().CommitteeIndex != 0 {
+		return 0, 0, pubsub.ValidationReject, errors.New("attestation data's committee index must be 0")
 	}
-
 	valCount, err := helpers.ActiveValidatorCount(ctx, bs, slots.ToEpoch(a.GetData().Slot))
 	if err != nil {
 		return 0, 0, pubsub.ValidationIgnore, err
@@ -369,29 +356,6 @@ func validateAttestingIndex(
 	return pubsub.ValidationAccept, nil
 }
 
-// validateGloasCommitteeIndex validates committee index rules for Gloas fork.
-// [REJECT] attestation.data.index < 2. (New in Gloas)
-// [REJECT] attestation.data.index == 0 if block.slot == attestation.data.slot. (New in Gloas)
-func (s *Service) validateGloasCommitteeIndex(data *eth.AttestationData) (pubsub.ValidationResult, error) {
-	if data.CommitteeIndex >= 2 {
-		return pubsub.ValidationReject, errors.New("attestation data's committee index must be < 2")
-	}
-
-	// Same-slot attestations must use committee index 0
-	if data.CommitteeIndex != 0 {
-		blockRoot := bytesutil.ToBytes32(data.BeaconBlockRoot)
-		slot, err := s.cfg.chain.RecentBlockSlot(blockRoot)
-		if err != nil {
-			return pubsub.ValidationIgnore, err
-		}
-		if slot == data.Slot {
-			return pubsub.ValidationReject, errors.New("same slot attestations must use committee index 0")
-		}
-	}
-
-	return pubsub.ValidationAccept, nil
-}
-
 // generateUnaggregatedAttCacheKey generates the cache key for unaggregated attestation tracking.
 func generateUnaggregatedAttCacheKey(att eth.Att) (string, error) {
 	var attester uint64

beacon-chain/sync/validate_beacon_attestation_test.go

@@ -684,75 +684,3 @@ func Test_validateCommitteeIndexAndCount_Boundary(t *testing.T) {
 	require.ErrorContains(t, "committee index", err)
 	require.Equal(t, pubsub.ValidationReject, res)
 }
-
-func Test_validateGloasCommitteeIndex(t *testing.T) {
-	tests := []struct {
-		name           string
-		committeeIndex primitives.CommitteeIndex
-		attestationSlot primitives.Slot
-		blockSlot      primitives.Slot
-		wantResult     pubsub.ValidationResult
-		wantErr        string
-	}{
-		{
-			name:           "committee index >= 2 should reject",
-			committeeIndex: 2,
-			attestationSlot: 10,
-			blockSlot:      10,
-			wantResult:     pubsub.ValidationReject,
-			wantErr:        "committee index must be < 2",
-		},
-		{
-			name:           "committee index 0 should accept",
-			committeeIndex: 0,
-			attestationSlot: 10,
-			blockSlot:      10,
-			wantResult:     pubsub.ValidationAccept,
-			wantErr:        "",
-		},
-		{
-			name:           "committee index 1 different-slot should accept",
-			committeeIndex: 1,
-			attestationSlot: 10,
-			blockSlot:      9,
-			wantResult:     pubsub.ValidationAccept,
-			wantErr:        "",
-		},
-		{
-			name:           "committee index 1 same-slot should reject",
-			committeeIndex: 1,
-			attestationSlot: 10,
-			blockSlot:      10,
-			wantResult:     pubsub.ValidationReject,
-			wantErr:        "same slot attestations must use committee index 0",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			mockChain := &mockChain.ChainService{
-				BlockSlot: tt.blockSlot,
-			}
-			s := &Service{
-				cfg: &config{
-					chain: mockChain,
-				},
-			}
-
-			data := &ethpb.AttestationData{
-				Slot:            tt.attestationSlot,
-				CommitteeIndex:  tt.committeeIndex,
-				BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot"), 32),
-			}
-
-			result, err := s.validateGloasCommitteeIndex(data)
-
-			require.Equal(t, tt.wantResult, result)
-			if tt.wantErr != "" {
-				require.ErrorContains(t, tt.wantErr, err)
-			} else {
-				require.NoError(t, err)
-			}
-		})
-	}
-}

beacon-chain/sync/validate_beacon_block_gloas.go

@@ -1,61 +0,0 @@
-package sync
-
-import (
-	"context"
-
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	consensusblocks "github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/pkg/errors"
-)
-
-// validateExecutionPayloadBid validates execution payload bid gossip rules.
-// [REJECT] The bid's parent (defined by bid.parent_block_root) equals the block's parent (defined by block.parent_root).
-// [REJECT] The length of KZG commitments is less than or equal to the limitation defined in the consensus layer --
-// i.e. validate that len(bid.blob_kzg_commitments) <= get_blob_parameters(get_current_epoch(state)).max_blobs_per_block
-func (s *Service) validateExecutionPayloadBid(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock) (pubsub.ValidationResult, error) {
-	if blk.Version() < version.Gloas {
-		return pubsub.ValidationAccept, nil
-	}
-	signedBid, err := blk.Body().SignedExecutionPayloadBid()
-	if err != nil {
-		return pubsub.ValidationIgnore, errors.Wrap(err, "unable to read bid from block")
-	}
-	wrappedBid, err := consensusblocks.WrappedROSignedExecutionPayloadBid(signedBid)
-	if err != nil {
-		return pubsub.ValidationIgnore, errors.Wrap(err, "unable to wrap signed execution payload bid")
-	}
-	bid, err := wrappedBid.Bid()
-	if err != nil {
-		return pubsub.ValidationIgnore, errors.Wrap(err, "unable to read bid from signed execution payload bid")
-	}
-
-	if bid.ParentBlockRoot() != blk.ParentRoot() {
-		return pubsub.ValidationReject, errors.New("bid parent block root does not match block parent root")
-	}
-
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlockAtEpoch(slots.ToEpoch(blk.Slot()))
-	if bid.BlobKzgCommitmentCount() > uint64(maxBlobsPerBlock) {
-		return pubsub.ValidationReject, errors.Wrapf(errRejectCommitmentLen, "%d > %d", bid.BlobKzgCommitmentCount(), maxBlobsPerBlock)
-	}
-	return pubsub.ValidationAccept, nil
-}
-
-// validateExecutionPayloadBidParentSeen validates parent payload gossip rules.
-// [IGNORE] The block's parent execution payload (defined by bid.parent_block_hash) has been seen
-// (via gossip or non-gossip sources) (a client MAY queue blocks for processing once the parent payload is retrieved).
-func (s *Service) validateExecutionPayloadBidParentSeen(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock) (pubsub.ValidationResult, error) {
-	// TODO: Requires blockchain service changes to expose parent payload seen status
-	return pubsub.ValidationAccept, nil
-}
-
-// validateExecutionPayloadBidParentValid validates parent payload verification status.
-// If execution_payload verification of block's execution payload parent by an execution node is complete:
-// [REJECT] The block's execution payload parent (defined by bid.parent_block_hash) passes all validation.
-func (s *Service) validateExecutionPayloadBidParentValid(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock) (pubsub.ValidationResult, error) {
-	// TODO: Requires blockchain service changes to expose execution payload parent validation status.
-	return pubsub.ValidationAccept, nil
-}

beacon-chain/sync/validate_beacon_block_gloas_test.go

@@ -1,75 +0,0 @@
-package sync
-
-import (
-	"context"
-	"testing"
-
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/stretchr/testify/require"
-)
-
-func TestValidateExecutionPayloadBid_Accept(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	ctx := context.Background()
-
-	parentRoot := bytesutil.PadTo([]byte{0x01}, fieldparams.RootLength)
-	block := util.NewBeaconBlockGloas()
-	block.Block.ParentRoot = parentRoot
-	block.Block.Body.SignedExecutionPayloadBid.Message.ParentBlockRoot = parentRoot
-	block.Block.Body.SignedExecutionPayloadBid.Message.BlobKzgCommitments = nil
-
-	wsb, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(t, err)
-
-	s := &Service{}
-	res, err := s.validateExecutionPayloadBid(ctx, wsb.Block())
-	require.NoError(t, err)
-	require.Equal(t, pubsub.ValidationAccept, res)
-}
-
-func TestValidateExecutionPayloadBid_RejectParentRootMismatch(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	ctx := context.Background()
-
-	block := util.NewBeaconBlockGloas()
-	block.Block.ParentRoot = bytesutil.PadTo([]byte{0x01}, fieldparams.RootLength)
-	block.Block.Body.SignedExecutionPayloadBid.Message.ParentBlockRoot = bytesutil.PadTo([]byte{0x02}, fieldparams.RootLength)
-
-	wsb, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(t, err)
-
-	s := &Service{}
-	res, err := s.validateExecutionPayloadBid(ctx, wsb.Block())
-	require.Error(t, err)
-	require.Equal(t, pubsub.ValidationReject, res)
-}
-
-func TestValidateExecutionPayloadBid_RejectTooManyCommitments(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	ctx := context.Background()
-
-	parentRoot := bytesutil.PadTo([]byte{0x01}, fieldparams.RootLength)
-	block := util.NewBeaconBlockGloas()
-	block.Block.ParentRoot = parentRoot
-	block.Block.Body.SignedExecutionPayloadBid.Message.ParentBlockRoot = parentRoot
-
-	maxBlobs := params.BeaconConfig().MaxBlobsPerBlockAtEpoch(0)
-	commitments := make([][]byte, maxBlobs+1)
-	for i := range commitments {
-		commitments[i] = bytesutil.PadTo([]byte{0x02}, fieldparams.BLSPubkeyLength)
-	}
-	block.Block.Body.SignedExecutionPayloadBid.Message.BlobKzgCommitments = commitments
-
-	wsb, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(t, err)
-
-	s := &Service{}
-	res, err := s.validateExecutionPayloadBid(ctx, wsb.Block())
-	require.Error(t, err)
-	require.Equal(t, pubsub.ValidationReject, res)
-}

beacon-chain/sync/validate_beacon_blocks.go

@@ -127,9 +127,6 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 		log.WithError(err).WithFields(getBlockFields(blk)).Debug("Received block with an invalid parent")
 		return pubsub.ValidationReject, err
 	}
-	if res, err := s.validateExecutionPayloadBidParentValid(ctx, blk.Block()); err != nil {
-		return res, err
-	}
 
 	s.pendingQueueLock.RLock()
 	if s.seenPendingBlocks[blockRoot] {
@@ -201,16 +198,6 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 		log.WithError(err).WithFields(getBlockFields(blk)).Debug("Could not identify parent for block")
 		return pubsub.ValidationIgnore, err
 	}
-	if res, err := s.validateExecutionPayloadBidParentSeen(ctx, blk.Block()); err != nil {
-		return res, err
-	}
-
-	if res, err := s.validateExecutionPayloadBid(ctx, blk.Block()); err != nil {
-		if res == pubsub.ValidationReject {
-			s.setBadBlock(ctx, blockRoot)
-		}
-		return res, err
-	}
 
 	err = s.validateBeaconBlock(ctx, blk, blockRoot)
 	if err != nil {
@@ -378,7 +365,7 @@ func (s *Service) blockVerifyingState(ctx context.Context, blk interfaces.ReadOn
 }
 
 func validateDenebBeaconBlock(blk interfaces.ReadOnlyBeaconBlock) error {
-	if blk.Version() < version.Deneb || blk.Version() >= version.Gloas {
+	if blk.Version() < version.Deneb {
 		return nil
 	}
 	commits, err := blk.Body().BlobKzgCommitments()
@@ -411,10 +398,6 @@ func validateDenebBeaconBlock(blk interfaces.ReadOnlyBeaconBlock) error {
 //	      [IGNORE] The block's parent (defined by block.parent_root) passes all validation (including execution
 //	       node verification of the block.body.execution_payload).
 func (s *Service) validateBellatrixBeaconBlock(ctx context.Context, verifyingState state.ReadOnlyBeaconState, blk interfaces.ReadOnlyBeaconBlock) error {
-	if blk.Version() >= version.Gloas {
-		return nil
-	}
-
 	// Error if block and state are not the same version
 	if verifyingState.Version() != blk.Version() {
 		return errors.New("block and state are not the same version")

changelog/james-prysm_calculate-post-state.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- refactors calculate state root and breaks up into calculate post state function.

changelog/kasey_copy-free-balance-lookup.md

@@ -1,2 +0,0 @@
-### Fixed
-- Avoid copying the full finalized state every time we compute cgc.

changelog/terence_gloas-attestation-validation.md

@@ -1,3 +0,0 @@
-### Added
-
-- Add gossip beacon attestation validation conditions for Gloas fork

changelog/terence_gloas-beacon-block-bid-gossip-validation.md

@@ -1,3 +0,0 @@
-### Added
-
-- Add Gloas beacon block gossip validation for execution payload bids