Add hashtree for hashing

* Proposer checks gas limit before accepting builder's bid

* James feedback

* Use cache

WORKSPACE

@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-alpha.3"
+consensus_spec_version = "v1.5.0-alpha.4"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-+byv+GUOQytex5GgtjBGVoNDseJZbiBdAjEtlgCbjEo=",
+    integrity = "sha256-sSw6c9IR/ZiWjyk1cbfVGC/aUkId4r7+eSl3haWsq0E=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -259,7 +259,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-JJUy/jT1h3kGQkinTuzL7gMOA1+qgmPgJXVrYuH63Cg=",
+    integrity = "sha256-OGlKhbA6TjTP0p1ojXVCJPzLEHJzewKkhAa+PQggoiU=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -275,7 +275,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-T2VM4Qd0SwgGnTjWxjOX297DqEsovO9Ueij1UEJy48Y=",
+    integrity = "sha256-ah2Gj4ci5hw5vQgpUWkNjEQutoBCepg5jcpTi0DKVB0=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -290,7 +290,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-OP9BCBcQ7i+93bwj7ktY8pZ5uWsGjgTe4XTp7BDhX+I=",
+    integrity = "sha256-I+llAsIF6lPP8RUtZ2DFsJqtCs4UPh+st3hFs12FWpY=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

beacon-chain/blockchain/process_block_test.go

@@ -2044,7 +2044,11 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 
 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
-		b, err := util.GenerateFullBlockElectra(st, keys, util.DefaultBlockGenConfig(), 1)
+		defaultConfig := util.DefaultBlockGenConfig()
+		defaultConfig.NumWithdrawalRequests = 1
+		defaultConfig.NumDepositRequests = 2
+		defaultConfig.NumConsolidationRequests = 1
+		b, err := util.GenerateFullBlockElectra(st, keys, defaultConfig, 1)
 		require.NoError(t, err)
 		wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 		require.NoError(t, err)
@@ -2059,7 +2063,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 
 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
-		b, err = util.GenerateFullBlockElectra(st, keys, util.DefaultBlockGenConfig(), 2)
+		b, err = util.GenerateFullBlockElectra(st, keys, defaultConfig, 2)
 		require.NoError(t, err)
 		wsb, err = consensusblocks.NewSignedBeaconBlock(b)
 		require.NoError(t, err)
@@ -2067,7 +2071,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 		// prepare another block that is not inserted
 		st3, err := transition.ExecuteStateTransition(ctx, st, wsb)
 		require.NoError(t, err)
-		b3, err := util.GenerateFullBlockElectra(st3, keys, util.DefaultBlockGenConfig(), 3)
+		b3, err := util.GenerateFullBlockElectra(st3, keys, defaultConfig, 3)
 		require.NoError(t, err)
 		wsb3, err := consensusblocks.NewSignedBeaconBlock(b3)
 		require.NoError(t, err)

beacon-chain/blockchain/receive_attestation.go

@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -190,13 +191,26 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 		}
 
 		if err := s.receiveAttestationNoPubsub(ctx, a, disparity); err != nil {
-			log.WithFields(logrus.Fields{
-				"slot":             a.GetData().Slot,
-				"committeeIndex":   a.GetData().CommitteeIndex,
-				"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().BeaconBlockRoot)),
-				"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().Target.Root)),
-				"aggregationCount": a.GetAggregationBits().Count(),
-			}).WithError(err).Warn("Could not process attestation for fork choice")
+			var fields logrus.Fields
+			if a.Version() >= version.Electra {
+				fields = logrus.Fields{
+					"slot":             a.GetData().Slot,
+					"committeeCount":   a.CommitteeBitsVal().Count(),
+					"committeeIndices": a.CommitteeBitsVal().BitIndices(),
+					"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().BeaconBlockRoot)),
+					"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().Target.Root)),
+					"aggregatedCount":  a.GetAggregationBits().Count(),
+				}
+			} else {
+				fields = logrus.Fields{
+					"slot":            a.GetData().Slot,
+					"committeeIndex":  a.GetData().CommitteeIndex,
+					"beaconBlockRoot": fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().BeaconBlockRoot)),
+					"targetRoot":      fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().Target.Root)),
+					"aggregatedCount": a.GetAggregationBits().Count(),
+				}
+			}
+			log.WithFields(fields).WithError(err).Warn("Could not process attestation for fork choice")
 		}
 	}
 }

beacon-chain/core/blocks/attestation.go

@@ -110,25 +110,7 @@ func VerifyAttestationNoVerifySignature(
 
 	var indexedAtt ethpb.IndexedAtt
 
-	if att.Version() < version.Electra {
-		if uint64(att.GetData().CommitteeIndex) >= c {
-			return fmt.Errorf("committee index %d >= committee count %d", att.GetData().CommitteeIndex, c)
-		}
-
-		if err = helpers.VerifyAttestationBitfieldLengths(ctx, beaconState, att); err != nil {
-			return errors.Wrap(err, "could not verify attestation bitfields")
-		}
-
-		// Verify attesting indices are correct.
-		committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.GetData().Slot, att.GetData().CommitteeIndex)
-		if err != nil {
-			return err
-		}
-		indexedAtt, err = attestation.ConvertToIndexed(ctx, att, committee)
-		if err != nil {
-			return err
-		}
-	} else {
+	if att.Version() >= version.Electra {
 		if att.GetData().CommitteeIndex != 0 {
 			return errors.New("committee index must be 0 post-Electra")
 		}
@@ -154,6 +136,29 @@ func VerifyAttestationNoVerifySignature(
 		if err != nil {
 			return err
 		}
+	} else {
+		if uint64(att.GetData().CommitteeIndex) >= c {
+			return fmt.Errorf("committee index %d >= committee count %d", att.GetData().CommitteeIndex, c)
+		}
+
+		// Verify attesting indices are correct.
+		committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.GetData().Slot, att.GetData().CommitteeIndex)
+		if err != nil {
+			return err
+		}
+
+		if committee == nil {
+			return errors.New("no committee exist for this attestation")
+		}
+
+		if err := helpers.VerifyBitfieldLength(att.GetAggregationBits(), uint64(len(committee))); err != nil {
+			return errors.Wrap(err, "failed to verify aggregation bitfield")
+		}
+
+		indexedAtt, err = attestation.ConvertToIndexed(ctx, att, committee)
+		if err != nil {
+			return err
+		}
 	}
 
 	return attestation.IsValidAttestationIndices(ctx, indexedAtt)

beacon-chain/core/blocks/exports_test.go

@@ -1,3 +1,5 @@
 package blocks
 
 var ProcessBLSToExecutionChange = processBLSToExecutionChange
+
+var VerifyBlobCommitmentCount = verifyBlobCommitmentCount

beacon-chain/core/blocks/payload.go

@@ -2,11 +2,13 @@ package blocks
 
 import (
 	"bytes"
+	"fmt"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	consensus_types "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
@@ -200,13 +202,13 @@ func ValidatePayload(st state.BeaconState, payload interfaces.ExecutionData) err
 //	    block_hash=payload.block_hash,
 //	    transactions_root=hash_tree_root(payload.transactions),
 //	)
-func ProcessPayload(st state.BeaconState, payload interfaces.ExecutionData) (state.BeaconState, error) {
-	var err error
-	if st.Version() >= version.Capella {
-		st, err = ProcessWithdrawals(st, payload)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not process withdrawals")
-		}
+func ProcessPayload(st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) (state.BeaconState, error) {
+	payload, err := body.Execution()
+	if err != nil {
+		return nil, err
+	}
+	if err := verifyBlobCommitmentCount(body); err != nil {
+		return nil, err
 	}
 	if err := ValidatePayloadWhenMergeCompletes(st, payload); err != nil {
 		return nil, err
@@ -220,70 +222,20 @@ func ProcessPayload(st state.BeaconState, payload interfaces.ExecutionData) (sta
 	return st, nil
 }
 
-// ValidatePayloadHeaderWhenMergeCompletes validates the payload header when the merge completes.
-func ValidatePayloadHeaderWhenMergeCompletes(st state.BeaconState, header interfaces.ExecutionData) error {
-	// Skip validation if the state is not merge compatible.
-	complete, err := IsMergeTransitionComplete(st)
-	if err != nil {
-		return err
-	}
-	if !complete {
+func verifyBlobCommitmentCount(body interfaces.ReadOnlyBeaconBlockBody) error {
+	if body.Version() < version.Deneb {
 		return nil
 	}
-	// Validate current header's parent hash matches state header's block hash.
-	h, err := st.LatestExecutionPayloadHeader()
+	kzgs, err := body.BlobKzgCommitments()
 	if err != nil {
 		return err
 	}
-	if !bytes.Equal(header.ParentHash(), h.BlockHash()) {
-		return ErrInvalidPayloadBlockHash
+	if len(kzgs) > field_params.MaxBlobsPerBlock {
+		return fmt.Errorf("too many kzg commitments in block: %d", len(kzgs))
 	}
 	return nil
 }
 
-// ValidatePayloadHeader validates the payload header.
-func ValidatePayloadHeader(st state.BeaconState, header interfaces.ExecutionData) error {
-	// Validate header's random mix matches with state in current epoch
-	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
-	if err != nil {
-		return err
-	}
-	if !bytes.Equal(header.PrevRandao(), random) {
-		return ErrInvalidPayloadPrevRandao
-	}
-
-	// Validate header's timestamp matches with state in current slot.
-	t, err := slots.ToTime(st.GenesisTime(), st.Slot())
-	if err != nil {
-		return err
-	}
-	if header.Timestamp() != uint64(t.Unix()) {
-		return ErrInvalidPayloadTimeStamp
-	}
-	return nil
-}
-
-// ProcessPayloadHeader processes the payload header.
-func ProcessPayloadHeader(st state.BeaconState, header interfaces.ExecutionData) (state.BeaconState, error) {
-	var err error
-	if st.Version() >= version.Capella {
-		st, err = ProcessWithdrawals(st, header)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not process withdrawals")
-		}
-	}
-	if err := ValidatePayloadHeaderWhenMergeCompletes(st, header); err != nil {
-		return nil, err
-	}
-	if err := ValidatePayloadHeader(st, header); err != nil {
-		return nil, err
-	}
-	if err := st.SetLatestExecutionPayloadHeader(header); err != nil {
-		return nil, err
-	}
-	return st, nil
-}
-
 // GetBlockPayloadHash returns the hash of the execution payload of the block
 func GetBlockPayloadHash(blk interfaces.ReadOnlyBeaconBlock) ([32]byte, error) {
 	var payloadHash [32]byte

beacon-chain/core/blocks/payload_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
@@ -13,6 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -581,14 +583,18 @@ func Test_ProcessPayload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			wrappedPayload, err := consensusblocks.WrappedExecutionPayload(tt.payload)
+			body, err := consensusblocks.NewBeaconBlockBody(&ethpb.BeaconBlockBodyBellatrix{
+				ExecutionPayload: tt.payload,
+			})
 			require.NoError(t, err)
-			st, err := blocks.ProcessPayload(st, wrappedPayload)
+			st, err := blocks.ProcessPayload(st, body)
 			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
 				require.Equal(t, tt.err, err)
-				want, err := consensusblocks.PayloadToHeader(wrappedPayload)
+				payload, err := body.Execution()
+				require.NoError(t, err)
+				want, err := consensusblocks.PayloadToHeader(payload)
 				require.Equal(t, tt.err, err)
 				h, err := st.LatestExecutionPayloadHeader()
 				require.NoError(t, err)
@@ -609,13 +615,15 @@ func Test_ProcessPayloadCapella(t *testing.T) {
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	require.NoError(t, err)
 	payload.PrevRandao = random
-	wrapped, err := consensusblocks.WrappedExecutionPayloadCapella(payload)
+	body, err := consensusblocks.NewBeaconBlockBody(&ethpb.BeaconBlockBodyCapella{
+		ExecutionPayload: payload,
+	})
 	require.NoError(t, err)
-	_, err = blocks.ProcessPayload(st, wrapped)
+	_, err = blocks.ProcessPayload(st, body)
 	require.NoError(t, err)
 }
 
-func Test_ProcessPayloadHeader(t *testing.T) {
+func Test_ProcessPayload_Blinded(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	require.NoError(t, err)
@@ -663,7 +671,13 @@ func Test_ProcessPayloadHeader(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			st, err := blocks.ProcessPayloadHeader(st, tt.header)
+			p, ok := tt.header.Proto().(*enginev1.ExecutionPayloadHeader)
+			require.Equal(t, true, ok)
+			body, err := consensusblocks.NewBeaconBlockBody(&ethpb.BlindedBeaconBlockBodyBellatrix{
+				ExecutionPayloadHeader: p,
+			})
+			require.NoError(t, err)
+			st, err := blocks.ProcessPayload(st, body)
 			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
@@ -728,7 +742,7 @@ func Test_ValidatePayloadHeader(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err = blocks.ValidatePayloadHeader(st, tt.header)
+			err = blocks.ValidatePayload(st, tt.header)
 			require.Equal(t, tt.err, err)
 		})
 	}
@@ -785,7 +799,7 @@ func Test_ValidatePayloadHeaderWhenMergeCompletes(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err = blocks.ValidatePayloadHeaderWhenMergeCompletes(tt.state, tt.header)
+			err = blocks.ValidatePayloadWhenMergeCompletes(tt.state, tt.header)
 			require.Equal(t, tt.err, err)
 		})
 	}
@@ -906,3 +920,15 @@ func emptyPayloadCapella() *enginev1.ExecutionPayloadCapella {
 		Withdrawals:   make([]*enginev1.Withdrawal, 0),
 	}
 }
+
+func TestVerifyBlobCommitmentCount(t *testing.T) {
+	b := &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{}}
+	rb, err := consensusblocks.NewBeaconBlock(b)
+	require.NoError(t, err)
+	require.NoError(t, blocks.VerifyBlobCommitmentCount(rb.Body()))
+
+	b = &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{BlobKzgCommitments: make([][]byte, fieldparams.MaxBlobsPerBlock+1)}}
+	rb, err = consensusblocks.NewBeaconBlock(b)
+	require.NoError(t, err)
+	require.ErrorContains(t, fmt.Sprintf("too many kzg commitments in block: %d", fieldparams.MaxBlobsPerBlock+1), blocks.VerifyBlobCommitmentCount(rb.Body()))
+}

beacon-chain/core/electra/consolidations.go

@@ -49,7 +49,7 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 		return errors.New("nil state")
 	}
 
-	currentEpoch := slots.ToEpoch(st.Slot())
+	nextEpoch := slots.ToEpoch(st.Slot()) + 1
 
 	var nextPendingConsolidation uint64
 	pendingConsolidations, err := st.PendingConsolidations()
@@ -66,7 +66,7 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 			nextPendingConsolidation++
 			continue
 		}
-		if sourceValidator.WithdrawableEpoch > currentEpoch {
+		if sourceValidator.WithdrawableEpoch > nextEpoch {
 			break
 		}
 

beacon-chain/core/electra/deposits.go

@@ -248,7 +248,7 @@ func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, ac
 
 	// constants
 	ffe := params.BeaconConfig().FarFutureEpoch
-	curEpoch := slots.ToEpoch(st.Slot())
+	nextEpoch := slots.ToEpoch(st.Slot()) + 1
 
 	for _, balanceDeposit := range deposits {
 		v, err := st.ValidatorAtIndexReadOnly(balanceDeposit.Index)
@@ -259,7 +259,7 @@ func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, ac
 		// If the validator is currently exiting, postpone the deposit until after the withdrawable
 		// epoch.
 		if v.ExitEpoch() < ffe {
-			if curEpoch <= v.WithdrawableEpoch() {
+			if nextEpoch <= v.WithdrawableEpoch() {
 				depositsToPostpone = append(depositsToPostpone, balanceDeposit)
 			} else {
 				// The deposited balance will never become active. Therefore, we increase the balance but do

beacon-chain/core/epoch/BUILD.bazel

@@ -22,7 +22,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
@@ -53,7 +52,6 @@ go_test(
         "//testing/util:go_default_library",
         "@com_github_google_go_cmp//cmp:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

beacon-chain/core/epoch/epoch_processing.go

@@ -20,32 +20,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
-// AttestingBalance returns the total balance from all the attesting indices.
-//
-// WARNING: This method allocates a new copy of the attesting validator indices set and is
-// considered to be very memory expensive. Avoid using this unless you really
-// need to get attesting balance from attestations.
-//
-// Spec pseudocode definition:
-//
-//	def get_attesting_balance(state: BeaconState, attestations: Sequence[PendingAttestation]) -> Gwei:
-//	  """
-//	  Return the combined effective balance of the set of unslashed validators participating in ``attestations``.
-//	  Note: ``get_total_balance`` returns ``EFFECTIVE_BALANCE_INCREMENT`` Gwei minimum to avoid divisions by zero.
-//	  """
-//	  return get_total_balance(state, get_unslashed_attesting_indices(state, attestations))
-func AttestingBalance(ctx context.Context, state state.ReadOnlyBeaconState, atts []*ethpb.PendingAttestation) (uint64, error) {
-	indices, err := UnslashedAttestingIndices(ctx, state, atts)
-	if err != nil {
-		return 0, errors.Wrap(err, "could not get attesting indices")
-	}
-	return helpers.TotalBalance(state, indices), nil
-}
-
 // ProcessRegistryUpdates rotates validators in and out of active pool.
 // the amount to rotate is determined churn limit.
 //
@@ -455,51 +432,3 @@ func ProcessFinalUpdates(state state.BeaconState) (state.BeaconState, error) {
 
 	return state, nil
 }
-
-// UnslashedAttestingIndices returns all the attesting indices from a list of attestations,
-// it sorts the indices and filters out the slashed ones.
-//
-// Spec pseudocode definition:
-//
-//	def get_unslashed_attesting_indices(state: BeaconState,
-//	                                  attestations: Sequence[PendingAttestation]) -> Set[ValidatorIndex]:
-//	  output = set()  # type: Set[ValidatorIndex]
-//	  for a in attestations:
-//	      output = output.union(get_attesting_indices(state, a.data, a.aggregation_bits))
-//	  return set(filter(lambda index: not state.validators[index].slashed, output))
-func UnslashedAttestingIndices(ctx context.Context, state state.ReadOnlyBeaconState, atts []*ethpb.PendingAttestation) ([]primitives.ValidatorIndex, error) {
-	var setIndices []primitives.ValidatorIndex
-	seen := make(map[uint64]bool)
-
-	for _, att := range atts {
-		committee, err := helpers.BeaconCommitteeFromState(ctx, state, att.GetData().Slot, att.GetData().CommitteeIndex)
-		if err != nil {
-			return nil, err
-		}
-		attestingIndices, err := attestation.AttestingIndices(att, committee)
-		if err != nil {
-			return nil, err
-		}
-		// Create a set for attesting indices
-		for _, index := range attestingIndices {
-			if !seen[index] {
-				setIndices = append(setIndices, primitives.ValidatorIndex(index))
-			}
-			seen[index] = true
-		}
-	}
-	// Sort the attesting set indices by increasing order.
-	sort.Slice(setIndices, func(i, j int) bool { return setIndices[i] < setIndices[j] })
-	// Remove the slashed validator indices.
-	for i := 0; i < len(setIndices); i++ {
-		v, err := state.ValidatorAtIndexReadOnly(setIndices[i])
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to look up validator")
-		}
-		if !v.IsNil() && v.Slashed() {
-			setIndices = append(setIndices[:i], setIndices[i+1:]...)
-		}
-	}
-
-	return setIndices, nil
-}

beacon-chain/core/epoch/epoch_processing_test.go

@@ -6,7 +6,6 @@ import (
 	"math"
 	"testing"
 
-	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
@@ -24,131 +23,6 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
-	// Generate 2 attestations.
-	atts := make([]*ethpb.PendingAttestation, 2)
-	for i := 0; i < len(atts); i++ {
-		atts[i] = &ethpb.PendingAttestation{
-			Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, fieldparams.RootLength)},
-			},
-			AggregationBits: bitfield.Bitlist{0x00, 0xFF, 0xFF, 0xFF},
-		}
-	}
-
-	// Generate validators and state for the 2 attestations.
-	validatorCount := 1000
-	validators := make([]*ethpb.Validator, validatorCount)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-		}
-	}
-	base := &ethpb.BeaconState{
-		Validators:  validators,
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	}
-	beaconState, err := state_native.InitializeFromProtoPhase0(base)
-	require.NoError(t, err)
-
-	indices, err := epoch.UnslashedAttestingIndices(context.Background(), beaconState, atts)
-	require.NoError(t, err)
-	for i := 0; i < len(indices)-1; i++ {
-		if indices[i] >= indices[i+1] {
-			t.Error("sorted indices not sorted or duplicated")
-		}
-	}
-
-	// Verify the slashed validator is filtered.
-	slashedValidator := indices[0]
-	validators = beaconState.Validators()
-	validators[slashedValidator].Slashed = true
-	require.NoError(t, beaconState.SetValidators(validators))
-	indices, err = epoch.UnslashedAttestingIndices(context.Background(), beaconState, atts)
-	require.NoError(t, err)
-	for i := 0; i < len(indices); i++ {
-		assert.NotEqual(t, slashedValidator, indices[i], "Slashed validator %d is not filtered", slashedValidator)
-	}
-}
-
-func TestUnslashedAttestingIndices_DuplicatedAttestations(t *testing.T) {
-	// Generate 5 of the same attestations.
-	atts := make([]*ethpb.PendingAttestation, 5)
-	for i := 0; i < len(atts); i++ {
-		atts[i] = &ethpb.PendingAttestation{
-			Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-				Target: &ethpb.Checkpoint{Epoch: 0}},
-			AggregationBits: bitfield.Bitlist{0x00, 0xFF, 0xFF, 0xFF},
-		}
-	}
-
-	// Generate validators and state for the 5 attestations.
-	validatorCount := 1000
-	validators := make([]*ethpb.Validator, validatorCount)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-		}
-	}
-	base := &ethpb.BeaconState{
-		Validators:  validators,
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	}
-	beaconState, err := state_native.InitializeFromProtoPhase0(base)
-	require.NoError(t, err)
-
-	indices, err := epoch.UnslashedAttestingIndices(context.Background(), beaconState, atts)
-	require.NoError(t, err)
-
-	for i := 0; i < len(indices)-1; i++ {
-		if indices[i] >= indices[i+1] {
-			t.Error("sorted indices not sorted or duplicated")
-		}
-	}
-}
-
-func TestAttestingBalance_CorrectBalance(t *testing.T) {
-	helpers.ClearCache()
-	// Generate 2 attestations.
-	atts := make([]*ethpb.PendingAttestation, 2)
-	for i := 0; i < len(atts); i++ {
-		atts[i] = &ethpb.PendingAttestation{
-			Data: &ethpb.AttestationData{
-				Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-				Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-				Slot:   primitives.Slot(i),
-			},
-			AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-				0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01},
-		}
-	}
-
-	// Generate validators with balances and state for the 2 attestations.
-	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	balances := make([]uint64, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{
-			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
-			EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-		}
-		balances[i] = params.BeaconConfig().MaxEffectiveBalance
-	}
-	base := &ethpb.BeaconState{
-		Slot:        2,
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-
-		Validators: validators,
-		Balances:   balances,
-	}
-	beaconState, err := state_native.InitializeFromProtoPhase0(base)
-	require.NoError(t, err)
-
-	balance, err := epoch.AttestingBalance(context.Background(), beaconState, atts)
-	require.NoError(t, err)
-	wanted := 256 * params.BeaconConfig().MaxEffectiveBalance
-	assert.Equal(t, wanted, balance)
-}
-
 func TestProcessSlashings_NotSlashed(t *testing.T) {
 	base := &ethpb.BeaconState{
 		Slot:       0,

beacon-chain/core/epoch/precompute/BUILD.bazel

@@ -47,7 +47,6 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",

beacon-chain/core/epoch/precompute/reward_penalty_test.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
@@ -59,90 +58,6 @@ func TestProcessRewardsAndPenaltiesPrecompute(t *testing.T) {
 	assert.Equal(t, wanted, beaconState.Balances()[0], "Unexpected balance")
 }
 
-func TestAttestationDeltaPrecompute(t *testing.T) {
-	e := params.BeaconConfig().SlotsPerEpoch
-	validatorCount := uint64(2048)
-	base := buildState(e+2, validatorCount)
-	atts := make([]*ethpb.PendingAttestation, 3)
-	var emptyRoot [32]byte
-	for i := 0; i < len(atts); i++ {
-		atts[i] = &ethpb.PendingAttestation{
-			Data: &ethpb.AttestationData{
-				Target: &ethpb.Checkpoint{
-					Root: emptyRoot[:],
-				},
-				Source: &ethpb.Checkpoint{
-					Root: emptyRoot[:],
-				},
-				BeaconBlockRoot: emptyRoot[:],
-			},
-			AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x01},
-			InclusionDelay:  1,
-		}
-	}
-	base.PreviousEpochAttestations = atts
-	beaconState, err := state_native.InitializeFromProtoPhase0(base)
-	require.NoError(t, err)
-	slashedAttestedIndices := []primitives.ValidatorIndex{1413}
-	for _, i := range slashedAttestedIndices {
-		vs := beaconState.Validators()
-		vs[i].Slashed = true
-		require.Equal(t, nil, beaconState.SetValidators(vs))
-	}
-
-	vp, bp, err := New(context.Background(), beaconState)
-	require.NoError(t, err)
-	vp, bp, err = ProcessAttestations(context.Background(), beaconState, vp, bp)
-	require.NoError(t, err)
-
-	// Add some variances to target and head balances.
-	// See: https://github.com/prysmaticlabs/prysm/issues/5593
-	bp.PrevEpochTargetAttested /= 2
-	bp.PrevEpochHeadAttested = bp.PrevEpochHeadAttested * 2 / 3
-	rewards, penalties, err := AttestationsDelta(beaconState, bp, vp)
-	require.NoError(t, err)
-	attestedBalance, err := epoch.AttestingBalance(context.Background(), beaconState, atts)
-	require.NoError(t, err)
-	totalBalance, err := helpers.TotalActiveBalance(beaconState)
-	require.NoError(t, err)
-
-	attestedIndices := []primitives.ValidatorIndex{55, 1339, 1746, 1811, 1569}
-	for _, i := range attestedIndices {
-		base, err := baseReward(beaconState, i)
-		require.NoError(t, err, "Could not get base reward")
-
-		// Base rewards for getting source right
-		wanted := attestedBalance*base/totalBalance +
-			bp.PrevEpochTargetAttested*base/totalBalance +
-			bp.PrevEpochHeadAttested*base/totalBalance
-		// Base rewards for proposer and attesters working together getting attestation
-		// on chain in the fatest manner
-		proposerReward := base / params.BeaconConfig().ProposerRewardQuotient
-		wanted += (base-proposerReward)*uint64(params.BeaconConfig().MinAttestationInclusionDelay) - 1
-		assert.Equal(t, wanted, rewards[i], "Unexpected reward balance for validator with index %d", i)
-		// Since all these validators attested, they shouldn't get penalized.
-		assert.Equal(t, uint64(0), penalties[i], "Unexpected penalty balance")
-	}
-
-	for _, i := range slashedAttestedIndices {
-		base, err := baseReward(beaconState, i)
-		assert.NoError(t, err, "Could not get base reward")
-		assert.Equal(t, uint64(0), rewards[i], "Unexpected slashed indices reward balance")
-		assert.Equal(t, 3*base, penalties[i], "Unexpected slashed indices penalty balance")
-	}
-
-	nonAttestedIndices := []primitives.ValidatorIndex{434, 677, 872, 791}
-	for _, i := range nonAttestedIndices {
-		base, err := baseReward(beaconState, i)
-		assert.NoError(t, err, "Could not get base reward")
-		wanted := 3 * base
-		// Since all these validators did not attest, they shouldn't get rewarded.
-		assert.Equal(t, uint64(0), rewards[i], "Unexpected reward balance")
-		// Base penalties for not attesting.
-		assert.Equal(t, wanted, penalties[i], "Unexpected penalty balance")
-	}
-}
-
 func TestAttestationDeltas_ZeroEpoch(t *testing.T) {
 	e := params.BeaconConfig().SlotsPerEpoch
 	validatorCount := uint64(2048)

beacon-chain/core/helpers/beacon_committee.go

@@ -337,24 +337,6 @@ func VerifyBitfieldLength(bf bitfield.Bitfield, committeeSize uint64) error {
 	return nil
 }
 
-// VerifyAttestationBitfieldLengths verifies that an attestations aggregation bitfields is
-// a valid length matching the size of the committee.
-func VerifyAttestationBitfieldLengths(ctx context.Context, state state.ReadOnlyBeaconState, att ethpb.Att) error {
-	committee, err := BeaconCommitteeFromState(ctx, state, att.GetData().Slot, att.GetData().CommitteeIndex)
-	if err != nil {
-		return errors.Wrap(err, "could not retrieve beacon committees")
-	}
-
-	if committee == nil {
-		return errors.New("no committee exist for this attestation")
-	}
-
-	if err := VerifyBitfieldLength(att.GetAggregationBits(), uint64(len(committee))); err != nil {
-		return errors.Wrap(err, "failed to verify aggregation bitfield")
-	}
-	return nil
-}
-
 // ShuffledIndices uses input beacon state and returns the shuffled indices of the input epoch,
 // the shuffled indices then can be used to break up into committees.
 func ShuffledIndices(s state.ReadOnlyBeaconState, epoch primitives.Epoch) ([]primitives.ValidatorIndex, error) {

beacon-chain/core/helpers/beacon_committee_test.go

@@ -403,7 +403,12 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
 		helpers.ClearCache()
 
 		require.NoError(t, state.SetSlot(tt.stateSlot))
-		err := helpers.VerifyAttestationBitfieldLengths(context.Background(), state, tt.attestation)
+		att := tt.attestation
+		// Verify attesting indices are correct.
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), state, att.GetData().Slot, att.GetData().CommitteeIndex)
+		require.NoError(t, err)
+		require.NotNil(t, committee)
+		err = helpers.VerifyBitfieldLength(att.GetAggregationBits(), uint64(len(committee)))
 		if tt.verificationFailure {
 			assert.NotNil(t, err, "Verification succeeded when it was supposed to fail")
 		} else {

beacon-chain/core/transition/transition.go

@@ -319,13 +319,17 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconSta
 func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.UpgradeState")
 	defer span.End()
+
 	var err error
+	upgraded := false
+
 	if time.CanUpgradeToAltair(state.Slot()) {
 		state, err = altair.UpgradeToAltair(ctx, state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
+		upgraded = true
 	}
 
 	if time.CanUpgradeToBellatrix(state.Slot()) {
@@ -334,6 +338,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
+		upgraded = true
 	}
 
 	if time.CanUpgradeToCapella(state.Slot()) {
@@ -342,6 +347,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
+		upgraded = true
 	}
 
 	if time.CanUpgradeToDeneb(state.Slot()) {
@@ -350,6 +356,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
+		upgraded = true
 	}
 
 	if time.CanUpgradeToElectra(state.Slot()) {
@@ -358,9 +365,13 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
+		upgraded = true
+	}
+
+	if upgraded {
+		log.Debugf("upgraded state to %s", version.String(state.Version()))
 	}
 
-	log.Debugf("upgraded state to %s", version.String(state.Version()))
 	return state, nil
 }
 

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition/interop"
 	v "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
@@ -328,20 +327,18 @@ func ProcessBlockForStateRoot(
 		if err != nil {
 			return nil, err
 		}
-		if blk.IsBlinded() {
-			state, err = b.ProcessPayloadHeader(state, executionData)
-		} else {
-			state, err = b.ProcessPayload(state, executionData)
+		if state.Version() >= version.Capella {
+			state, err = b.ProcessWithdrawals(state, executionData)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not process withdrawals")
+			}
 		}
+		state, err = b.ProcessPayload(state, blk.Body())
 		if err != nil {
 			return nil, errors.Wrap(err, "could not process execution data")
 		}
 	}
 
-	if err := VerifyBlobCommitmentCount(blk); err != nil {
-		return nil, err
-	}
-
 	randaoReveal := signed.Block().Body().RandaoReveal()
 	state, err = b.ProcessRandaoNoVerify(state, randaoReveal[:])
 	if err != nil {
@@ -377,20 +374,6 @@ func ProcessBlockForStateRoot(
 	return state, nil
 }
 
-func VerifyBlobCommitmentCount(blk interfaces.ReadOnlyBeaconBlock) error {
-	if blk.Version() < version.Deneb {
-		return nil
-	}
-	kzgs, err := blk.Body().BlobKzgCommitments()
-	if err != nil {
-		return err
-	}
-	if len(kzgs) > field_params.MaxBlobsPerBlock {
-		return fmt.Errorf("too many kzg commitments in block: %d", len(kzgs))
-	}
-	return nil
-}
-
 // This calls altair block operations.
 func altairOperations(
 	ctx context.Context,

beacon-chain/core/transition/transition_no_verify_sig_test.go

@@ -2,13 +2,11 @@ package transition_test
 
 import (
 	"context"
-	"fmt"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
-	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -212,15 +210,3 @@ func TestProcessBlockDifferentVersion(t *testing.T) {
 	_, _, err = transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, "state and block are different version. 0 != 1", err)
 }
-
-func TestVerifyBlobCommitmentCount(t *testing.T) {
-	b := &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{}}
-	rb, err := blocks.NewBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, transition.VerifyBlobCommitmentCount(rb))
-
-	b = &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{BlobKzgCommitments: make([][]byte, field_params.MaxBlobsPerBlock+1)}}
-	rb, err = blocks.NewBeaconBlock(b)
-	require.NoError(t, err)
-	require.ErrorContains(t, fmt.Sprintf("too many kzg commitments in block: %d", field_params.MaxBlobsPerBlock+1), transition.VerifyBlobCommitmentCount(rb))
-}

beacon-chain/execution/mock_test.go

@@ -84,11 +84,15 @@ func (s *mockEngine) callCount(method string) int {
 }
 
 func mockParseUintList(t *testing.T, data json.RawMessage) []uint64 {
-	var list []uint64
+	var list []string
 	if err := json.Unmarshal(data, &list); err != nil {
 		t.Fatalf("failed to parse uint list: %v", err)
 	}
-	return list
+	uints := make([]uint64, len(list))
+	for i, u := range list {
+		uints[i] = hexutil.MustDecodeUint64(u)
+	}
+	return uints
 }
 
 func mockParseHexByteList(t *testing.T, data json.RawMessage) []hexutil.Bytes {
@@ -117,7 +121,7 @@ func TestParseRequest(t *testing.T) {
 	ctx := context.Background()
 	cases := []struct {
 		method   string
-		uintArgs []uint64
+		hexArgs  []string // uint64 as hex
 		byteArgs []hexutil.Bytes
 	}{
 		{
@@ -135,26 +139,28 @@ func TestParseRequest(t *testing.T) {
 			},
 		},
 		{
-			method:   GetPayloadBodiesByRangeV1,
-			uintArgs: []uint64{0, 1},
+			method:  GetPayloadBodiesByRangeV1,
+			hexArgs: []string{hexutil.EncodeUint64(0), hexutil.EncodeUint64(1)},
 		},
 		{
-			method:   GetPayloadBodiesByRangeV2,
-			uintArgs: []uint64{math.MaxUint64, 1},
+			method:  GetPayloadBodiesByRangeV2,
+			hexArgs: []string{hexutil.EncodeUint64(math.MaxUint64), hexutil.EncodeUint64(1)},
 		},
 	}
 	for _, c := range cases {
 		t.Run(c.method, func(t *testing.T) {
 			cli, srv := newMockEngine(t)
-			srv.register(c.method, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			srv.register(c.method, func(msg *jsonrpcMessage, w http.ResponseWriter, _ *http.Request) {
 				require.Equal(t, c.method, msg.Method)
 				nr := uint64(len(c.byteArgs))
 				if len(c.byteArgs) > 0 {
 					require.DeepEqual(t, c.byteArgs, mockParseHexByteList(t, msg.Params))
 				}
-				if len(c.uintArgs) > 0 {
+				if len(c.hexArgs) > 0 {
 					rang := mockParseUintList(t, msg.Params)
-					require.DeepEqual(t, c.uintArgs, rang)
+					for i, r := range rang {
+						require.Equal(t, c.hexArgs[i], hexutil.EncodeUint64(r))
+					}
 					nr = rang[1]
 				}
 				mockWriteResult(t, w, msg, make([]*pb.ExecutionPayloadBody, nr))
@@ -165,18 +171,18 @@ func TestParseRequest(t *testing.T) {
 			if len(c.byteArgs) > 0 {
 				args = []interface{}{c.byteArgs}
 			}
-			if len(c.uintArgs) > 0 {
-				args = make([]interface{}, len(c.uintArgs))
-				for i := range c.uintArgs {
-					args[i] = c.uintArgs[i]
+			if len(c.hexArgs) > 0 {
+				args = make([]interface{}, len(c.hexArgs))
+				for i := range c.hexArgs {
+					args[i] = c.hexArgs[i]
 				}
 			}
 			require.NoError(t, cli.CallContext(ctx, &result, c.method, args...))
 			if len(c.byteArgs) > 0 {
 				require.Equal(t, len(c.byteArgs), len(result))
 			}
-			if len(c.uintArgs) > 0 {
-				require.Equal(t, int(c.uintArgs[1]), len(result))
+			if len(c.hexArgs) > 0 {
+				require.Equal(t, int(hexutil.MustDecodeUint64(c.hexArgs[1])), len(result))
 			}
 		})
 	}
@@ -203,7 +209,7 @@ func TestCallCount(t *testing.T) {
 	for _, c := range cases {
 		t.Run(c.method, func(t *testing.T) {
 			cli, srv := newMockEngine(t)
-			srv.register(c.method, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			srv.register(c.method, func(msg *jsonrpcMessage, w http.ResponseWriter, _ *http.Request) {
 				mockWriteResult(t, w, msg, nil)
 			})
 			for i := 0; i < c.count; i++ {

beacon-chain/execution/payload_body.go

@@ -5,6 +5,7 @@ import (
 	"sort"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -160,7 +161,7 @@ func computeRanges(hbns []hashBlockNumber) []byRangeReq {
 
 func (r *blindedBlockReconstructor) requestBodiesByRange(ctx context.Context, client RPCClient, method string, req byRangeReq) error {
 	result := make([]*pb.ExecutionPayloadBody, 0)
-	if err := client.CallContext(ctx, &result, method, req.start, req.count); err != nil {
+	if err := client.CallContext(ctx, &result, method, hexutil.EncodeUint64(req.start), hexutil.EncodeUint64(req.count)); err != nil {
 		return err
 	}
 	if uint64(len(result)) != req.count {

beacon-chain/p2p/testing/mock_peersprovider.go

@@ -16,6 +16,11 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
+const (
+	MockRawPeerId0 = "16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR"
+	MockRawPeerId1 = "16Uiu2HAm4HgJ9N1o222xK61o7LSgToYWoAy1wNTJRkh9gLZapVAy"
+)
+
 // MockPeersProvider implements PeersProvider for testing.
 type MockPeersProvider struct {
 	lock  sync.Mutex
@@ -50,7 +55,7 @@ func (m *MockPeersProvider) Peers() *peers.Status {
 			},
 		})
 		// Pretend we are connected to two peers
-		id0, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR")
+		id0, err := peer.Decode(MockRawPeerId0)
 		if err != nil {
 			log.WithError(err).Debug("Cannot decode")
 		}
@@ -61,7 +66,7 @@ func (m *MockPeersProvider) Peers() *peers.Status {
 		m.peers.Add(createENR(), id0, ma0, network.DirInbound)
 		m.peers.SetConnectionState(id0, peers.PeerConnected)
 		m.peers.SetChainState(id0, &pb.Status{FinalizedEpoch: 10})
-		id1, err := peer.Decode("16Uiu2HAm4HgJ9N1o222xK61o7LSgToYWoAy1wNTJRkh9gLZapVAy")
+		id1, err := peer.Decode(MockRawPeerId1)
 		if err != nil {
 			log.WithError(err).Debug("Cannot decode")
 		}

beacon-chain/rpc/prysm/v1alpha1/node/server_test.go

@@ -128,13 +128,12 @@ func TestNodeServer_GetPeer(t *testing.T) {
 	}
 	ethpb.RegisterNodeServer(server, ns)
 	reflection.Register(server)
-	firstPeer := peersProvider.Peers().All()[0]
 
-	res, err := ns.GetPeer(context.Background(), &ethpb.PeerRequest{PeerId: firstPeer.String()})
+	res, err := ns.GetPeer(context.Background(), &ethpb.PeerRequest{PeerId: mockP2p.MockRawPeerId0})
 	require.NoError(t, err)
-	assert.Equal(t, firstPeer.String(), res.PeerId, "Unexpected peer ID")
+	assert.Equal(t, "16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR" /* first peer's raw id */, res.PeerId, "Unexpected peer ID")
 	assert.Equal(t, int(ethpb.PeerDirection_INBOUND), int(res.Direction), "Expected 1st peer to be an inbound connection")
-	assert.Equal(t, ethpb.ConnectionState_CONNECTED, res.ConnectionState, "Expected peer to be connected")
+	assert.Equal(t, int(ethpb.ConnectionState_CONNECTED), int(res.ConnectionState), "Expected peer to be connected")
 }
 
 func TestNodeServer_ListPeers(t *testing.T) {
@@ -149,8 +148,25 @@ func TestNodeServer_ListPeers(t *testing.T) {
 	res, err := ns.ListPeers(context.Background(), &emptypb.Empty{})
 	require.NoError(t, err)
 	assert.Equal(t, 2, len(res.Peers))
-	assert.Equal(t, int(ethpb.PeerDirection_INBOUND), int(res.Peers[0].Direction))
-	assert.Equal(t, ethpb.PeerDirection_OUTBOUND, res.Peers[1].Direction)
+
+	var (
+		firstPeer  *ethpb.Peer
+		secondPeer *ethpb.Peer
+	)
+
+	for _, p := range res.Peers {
+		if p.PeerId == mockP2p.MockRawPeerId0 {
+			firstPeer = p
+		}
+		if p.PeerId == mockP2p.MockRawPeerId1 {
+			secondPeer = p
+		}
+	}
+
+	assert.NotNil(t, firstPeer)
+	assert.NotNil(t, secondPeer)
+	assert.Equal(t, int(ethpb.PeerDirection_INBOUND), int(firstPeer.Direction))
+	assert.Equal(t, int(ethpb.PeerDirection_OUTBOUND), int(secondPeer.Direction))
 }
 
 func TestNodeServer_GetETH1ConnectionStatus(t *testing.T) {

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

@@ -66,18 +66,12 @@ func (vs *Server) ProposeAttestationElectra(ctx context.Context, att *ethpb.Atte
 	ctx, span := trace.StartSpan(ctx, "AttesterServer.ProposeAttestationElectra")
 	defer span.End()
 
-	if att.GetData().CommitteeIndex != 0 {
-		return nil, status.Errorf(codes.InvalidArgument, "Committee index must be set to 0")
-	}
-	committeeIndices := helpers.CommitteeIndices(att.CommitteeBits)
-	if len(committeeIndices) == 0 {
-		return nil, status.Errorf(codes.InvalidArgument, "Committee bits has no bit set")
-	}
-	if len(committeeIndices) > 1 {
-		return nil, status.Errorf(codes.InvalidArgument, "Committee bits has more than one bit set")
+	committeeIndex, err := att.GetCommitteeIndex()
+	if err != nil {
+		return nil, err
 	}
 
-	resp, err := vs.proposeAtt(ctx, att, committeeIndices[0])
+	resp, err := vs.proposeAtt(ctx, att, committeeIndex)
 	if err != nil {
 		return nil, err
 	}

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

@@ -113,7 +113,7 @@ func TestProposeAttestation(t *testing.T) {
 			CommitteeBits: cb,
 		}
 		_, err = attesterServer.ProposeAttestationElectra(context.Background(), req)
-		assert.ErrorContains(t, "Committee index must be set to 0", err)
+		assert.ErrorContains(t, "attestation data's committee index must be 0 but was 1", err)
 	})
 	t.Run("Electra - no committee bit set", func(t *testing.T) {
 		state, err := util.NewBeaconStateElectra()
@@ -131,7 +131,7 @@ func TestProposeAttestation(t *testing.T) {
 			CommitteeBits: primitives.NewAttestationCommitteeBits(),
 		}
 		_, err = attesterServer.ProposeAttestationElectra(context.Background(), req)
-		assert.ErrorContains(t, "Committee bits has no bit set", err)
+		assert.ErrorContains(t, "exactly 1 committee index must be set but 0 were set", err)
 	})
 	t.Run("Electra - multiple committee bits set", func(t *testing.T) {
 		state, err := util.NewBeaconStateElectra()
@@ -152,7 +152,7 @@ func TestProposeAttestation(t *testing.T) {
 			CommitteeBits: cb,
 		}
 		_, err = attesterServer.ProposeAttestationElectra(context.Background(), req)
-		assert.ErrorContains(t, "Committee bits has more than one bit set", err)
+		assert.ErrorContains(t, "exactly 1 committee index must be set but 2 were set", err)
 	})
 }
 

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

@@ -242,6 +242,15 @@ func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot primitiv
 		return nil, fmt.Errorf("incorrect parent hash %#x != %#x", header.ParentHash(), h.BlockHash())
 	}
 
+	reg, err := vs.BlockBuilder.RegistrationByValidatorID(ctx, idx)
+	if err != nil {
+		log.WithError(err).Warn("Proposer: failed to get registration by validator ID, could not check gas limit")
+	} else {
+		if reg.GasLimit != header.GasLimit() {
+			return nil, fmt.Errorf("incorrect header gas limit %d != %d", reg.GasLimit, header.GasLimit())
+		}
+	}
+
 	t, err := slots.ToTime(uint64(vs.TimeFetcher.GenesisTime().Unix()), slot)
 	if err != nil {
 		return nil, err

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

@@ -720,6 +720,29 @@ func TestServer_getPayloadHeader(t *testing.T) {
 		Signature: sk.Sign(srCapella[:]).Marshal(),
 	}
 
+	incorrectGasLimitBid := &ethpb.BuilderBid{
+		Header: &v1.ExecutionPayloadHeader{
+			FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
+			StateRoot:        make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:     make([]byte, fieldparams.RootLength),
+			LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
+			PrevRandao:       make([]byte, fieldparams.RootLength),
+			BaseFeePerGas:    make([]byte, fieldparams.RootLength),
+			BlockHash:        make([]byte, fieldparams.RootLength),
+			TransactionsRoot: bytesutil.PadTo([]byte{1}, fieldparams.RootLength),
+			ParentHash:       params.BeaconConfig().ZeroHash[:],
+			Timestamp:        uint64(tiCapella.Unix()),
+			GasLimit:         100,
+		},
+		Pubkey: sk.PublicKey().Marshal(),
+		Value:  bytesutil.PadTo([]byte{1, 2, 3}, 32),
+	}
+	signedIncorrectGasLimitBid :=
+		&ethpb.SignedBuilderBid{
+			Message:   incorrectGasLimitBid,
+			Signature: sk.Sign(srCapella[:]).Marshal(),
+		}
+
 	require.NoError(t, err)
 	tests := []struct {
 		name                  string
@@ -832,6 +855,21 @@ func TestServer_getPayloadHeader(t *testing.T) {
 			},
 			err: "is different from head block version",
 		},
+		{
+			name: "incorrect gas limit",
+			mock: &builderTest.MockBuilderService{
+				Bid: signedIncorrectGasLimitBid,
+			},
+			fetcher: &blockchainTest.ChainService{
+				Block: func() interfaces.ReadOnlySignedBeaconBlock {
+					wb, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockBellatrix())
+					require.NoError(t, err)
+					wb.SetSlot(primitives.Slot(params.BeaconConfig().BellatrixForkEpoch) * params.BeaconConfig().SlotsPerEpoch)
+					return wb
+				}(),
+			},
+			err: "incorrect header gas limit 0 != 100",
+		},
 		{
 			name: "different bid version during hard fork",
 			mock: &builderTest.MockBuilderService{
@@ -850,9 +888,18 @@ func TestServer_getPayloadHeader(t *testing.T) {
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			vs := &Server{BlockBuilder: tc.mock, HeadFetcher: tc.fetcher, TimeFetcher: &blockchainTest.ChainService{
+			vs := &Server{BeaconDB: dbTest.SetupDB(t), BlockBuilder: tc.mock, HeadFetcher: tc.fetcher, TimeFetcher: &blockchainTest.ChainService{
 				Genesis: genesis,
 			}}
+			regCache := cache.NewRegistrationCache()
+			regCache.UpdateIndexToRegisteredMap(context.Background(), map[primitives.ValidatorIndex]*ethpb.ValidatorRegistrationV1{
+				0: {
+					GasLimit:     0,
+					FeeRecipient: make([]byte, 20),
+					Pubkey:       make([]byte, 48),
+				},
+			})
+			tc.mock.RegistrationCache = regCache
 			hb, err := vs.HeadFetcher.HeadBlock(context.Background())
 			require.NoError(t, err)
 			bid, err := vs.getPayloadHeaderFromBuilder(context.Background(), hb.Block().Slot(), 0)

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

@@ -59,14 +59,26 @@ func (vs *Server) getLocalPayload(ctx context.Context, blk interfaces.ReadOnlyBe
 	slot := blk.Slot()
 	vIdx := blk.ProposerIndex()
 	headRoot := blk.ParentRoot()
-	logFields := logrus.Fields{
-		"validatorIndex": vIdx,
-		"slot":           slot,
-		"headRoot":       fmt.Sprintf("%#x", headRoot),
-	}
-	payloadId, ok := vs.PayloadIDCache.PayloadID(slot, headRoot)
 
-	val, tracked := vs.TrackedValidatorsCache.Validator(vIdx)
+	return vs.getLocalPayloadFromEngine(ctx, st, headRoot, slot, vIdx)
+}
+
+// This returns the local execution payload of a slot, proposer ID, and parent root assuming payload Is cached.
+// If the payload ID is not cached, the function will prepare a new payload through local EL engine and return it by using the head state.
+func (vs *Server) getLocalPayloadFromEngine(
+	ctx context.Context,
+	st state.BeaconState,
+	parentRoot [32]byte,
+	slot primitives.Slot,
+	proposerId primitives.ValidatorIndex) (*consensusblocks.GetPayloadResponse, error) {
+	logFields := logrus.Fields{
+		"validatorIndex": proposerId,
+		"slot":           slot,
+		"headRoot":       fmt.Sprintf("%#x", parentRoot),
+	}
+	payloadId, ok := vs.PayloadIDCache.PayloadID(slot, parentRoot)
+
+	val, tracked := vs.TrackedValidatorsCache.Validator(proposerId)
 	if !tracked {
 		logrus.WithFields(logFields).Warn("could not find tracked proposer index")
 	}
@@ -135,7 +147,7 @@ func (vs *Server) getLocalPayload(ctx context.Context, blk interfaces.ReadOnlyBe
 			PrevRandao:            random,
 			SuggestedFeeRecipient: val.FeeRecipient[:],
 			Withdrawals:           withdrawals,
-			ParentBeaconBlockRoot: headRoot[:],
+			ParentBeaconBlockRoot: parentRoot[:],
 		})
 		if err != nil {
 			return nil, err

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

@@ -3,8 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "beacon_state_mainnet.go",
-        "beacon_state_minimal.go",  # keep
+        "beacon_state.go",
         "doc.go",
         "error.go",
         "getters_attestation.go",

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

@@ -1,5 +1,3 @@
-//go:build minimal
-
 package state_native
 
 import (

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

@@ -1,203 +0,0 @@
-//go:build !minimal
-
-package state_native
-
-import (
-	"encoding/json"
-	"sync"
-
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/fieldtrie"
-	customtypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native/custom-types"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native/types"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stateutil"
-	"github.com/prysmaticlabs/prysm/v5/config/features"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-)
-
-// BeaconState defines a struct containing utilities for the Ethereum Beacon Chain state, defining
-// getters and setters for its respective values and helpful functions such as HashTreeRoot().
-type BeaconState struct {
-	version                             int
-	genesisTime                         uint64
-	genesisValidatorsRoot               [32]byte
-	slot                                primitives.Slot
-	fork                                *ethpb.Fork
-	latestBlockHeader                   *ethpb.BeaconBlockHeader
-	blockRoots                          customtypes.BlockRoots
-	blockRootsMultiValue                *MultiValueBlockRoots
-	stateRoots                          customtypes.StateRoots
-	stateRootsMultiValue                *MultiValueStateRoots
-	historicalRoots                     customtypes.HistoricalRoots
-	historicalSummaries                 []*ethpb.HistoricalSummary
-	eth1Data                            *ethpb.Eth1Data
-	eth1DataVotes                       []*ethpb.Eth1Data
-	eth1DepositIndex                    uint64
-	validators                          []*ethpb.Validator
-	validatorsMultiValue                *MultiValueValidators
-	balances                            []uint64
-	balancesMultiValue                  *MultiValueBalances
-	randaoMixes                         customtypes.RandaoMixes
-	randaoMixesMultiValue               *MultiValueRandaoMixes
-	slashings                           []uint64
-	previousEpochAttestations           []*ethpb.PendingAttestation
-	currentEpochAttestations            []*ethpb.PendingAttestation
-	previousEpochParticipation          []byte
-	currentEpochParticipation           []byte
-	justificationBits                   bitfield.Bitvector4
-	previousJustifiedCheckpoint         *ethpb.Checkpoint
-	currentJustifiedCheckpoint          *ethpb.Checkpoint
-	finalizedCheckpoint                 *ethpb.Checkpoint
-	inactivityScores                    []uint64
-	inactivityScoresMultiValue          *MultiValueInactivityScores
-	currentSyncCommittee                *ethpb.SyncCommittee
-	nextSyncCommittee                   *ethpb.SyncCommittee
-	latestExecutionPayloadHeader        *enginev1.ExecutionPayloadHeader
-	latestExecutionPayloadHeaderCapella *enginev1.ExecutionPayloadHeaderCapella
-	latestExecutionPayloadHeaderDeneb   *enginev1.ExecutionPayloadHeaderDeneb
-	latestExecutionPayloadHeaderElectra *enginev1.ExecutionPayloadHeaderElectra
-	nextWithdrawalIndex                 uint64
-	nextWithdrawalValidatorIndex        primitives.ValidatorIndex
-
-	// Electra fields
-	depositRequestsStartIndex     uint64
-	depositBalanceToConsume       primitives.Gwei
-	exitBalanceToConsume          primitives.Gwei
-	earliestExitEpoch             primitives.Epoch
-	consolidationBalanceToConsume primitives.Gwei
-	earliestConsolidationEpoch    primitives.Epoch
-	pendingBalanceDeposits        []*ethpb.PendingBalanceDeposit    // pending_balance_deposits: List[PendingBalanceDeposit, PENDING_BALANCE_DEPOSITS_LIMIT]
-	pendingPartialWithdrawals     []*ethpb.PendingPartialWithdrawal // pending_partial_withdrawals: List[PartialWithdrawal, PENDING_PARTIAL_WITHDRAWALS_LIMIT]
-	pendingConsolidations         []*ethpb.PendingConsolidation     // pending_consolidations: List[PendingConsolidation, PENDING_CONSOLIDATIONS_LIMIT]
-
-	id                    uint64
-	lock                  sync.RWMutex
-	dirtyFields           map[types.FieldIndex]bool
-	dirtyIndices          map[types.FieldIndex][]uint64
-	stateFieldLeaves      map[types.FieldIndex]*fieldtrie.FieldTrie
-	rebuildTrie           map[types.FieldIndex]bool
-	valMapHandler         *stateutil.ValidatorMapHandler
-	validatorIndexCache   *finalizedValidatorIndexCache
-	merkleLayers          [][][]byte
-	sharedFieldReferences map[types.FieldIndex]*stateutil.Reference
-}
-
-type beaconStateMarshalable struct {
-	Version                             int                                     `json:"version" yaml:"version"`
-	GenesisTime                         uint64                                  `json:"genesis_time" yaml:"genesis_time"`
-	GenesisValidatorsRoot               [32]byte                                `json:"genesis_validators_root" yaml:"genesis_validators_root"`
-	Slot                                primitives.Slot                         `json:"slot" yaml:"slot"`
-	Fork                                *ethpb.Fork                             `json:"fork" yaml:"fork"`
-	LatestBlockHeader                   *ethpb.BeaconBlockHeader                `json:"latest_block_header" yaml:"latest_block_header"`
-	BlockRoots                          customtypes.BlockRoots                  `json:"block_roots" yaml:"block_roots"`
-	StateRoots                          customtypes.StateRoots                  `json:"state_roots" yaml:"state_roots"`
-	HistoricalRoots                     customtypes.HistoricalRoots             `json:"historical_roots" yaml:"historical_roots"`
-	HistoricalSummaries                 []*ethpb.HistoricalSummary              `json:"historical_summaries" yaml:"historical_summaries"`
-	Eth1Data                            *ethpb.Eth1Data                         `json:"eth_1_data" yaml:"eth_1_data"`
-	Eth1DataVotes                       []*ethpb.Eth1Data                       `json:"eth_1_data_votes" yaml:"eth_1_data_votes"`
-	Eth1DepositIndex                    uint64                                  `json:"eth_1_deposit_index" yaml:"eth_1_deposit_index"`
-	Validators                          []*ethpb.Validator                      `json:"validators" yaml:"validators"`
-	Balances                            []uint64                                `json:"balances" yaml:"balances"`
-	RandaoMixes                         customtypes.RandaoMixes                 `json:"randao_mixes" yaml:"randao_mixes"`
-	Slashings                           []uint64                                `json:"slashings" yaml:"slashings"`
-	PreviousEpochAttestations           []*ethpb.PendingAttestation             `json:"previous_epoch_attestations" yaml:"previous_epoch_attestations"`
-	CurrentEpochAttestations            []*ethpb.PendingAttestation             `json:"current_epoch_attestations" yaml:"current_epoch_attestations"`
-	PreviousEpochParticipation          []byte                                  `json:"previous_epoch_participation" yaml:"previous_epoch_participation"`
-	CurrentEpochParticipation           []byte                                  `json:"current_epoch_participation" yaml:"current_epoch_participation"`
-	JustificationBits                   bitfield.Bitvector4                     `json:"justification_bits" yaml:"justification_bits"`
-	PreviousJustifiedCheckpoint         *ethpb.Checkpoint                       `json:"previous_justified_checkpoint" yaml:"previous_justified_checkpoint"`
-	CurrentJustifiedCheckpoint          *ethpb.Checkpoint                       `json:"current_justified_checkpoint" yaml:"current_justified_checkpoint"`
-	FinalizedCheckpoint                 *ethpb.Checkpoint                       `json:"finalized_checkpoint" yaml:"finalized_checkpoint"`
-	InactivityScores                    []uint64                                `json:"inactivity_scores" yaml:"inactivity_scores"`
-	CurrentSyncCommittee                *ethpb.SyncCommittee                    `json:"current_sync_committee" yaml:"current_sync_committee"`
-	NextSyncCommittee                   *ethpb.SyncCommittee                    `json:"next_sync_committee" yaml:"next_sync_committee"`
-	LatestExecutionPayloadHeader        *enginev1.ExecutionPayloadHeader        `json:"latest_execution_payload_header" yaml:"latest_execution_payload_header"`
-	LatestExecutionPayloadHeaderCapella *enginev1.ExecutionPayloadHeaderCapella `json:"latest_execution_payload_header_capella" yaml:"latest_execution_payload_header_capella"`
-	LatestExecutionPayloadHeaderDeneb   *enginev1.ExecutionPayloadHeaderDeneb   `json:"latest_execution_payload_header_deneb" yaml:"latest_execution_payload_header_deneb"`
-	LatestExecutionPayloadHeaderElectra *enginev1.ExecutionPayloadHeaderElectra `json:"latest_execution_payload_header_electra" yaml:"latest_execution_payload_header_electra"`
-	NextWithdrawalIndex                 uint64                                  `json:"next_withdrawal_index" yaml:"next_withdrawal_index"`
-	NextWithdrawalValidatorIndex        primitives.ValidatorIndex               `json:"next_withdrawal_validator_index" yaml:"next_withdrawal_validator_index"`
-	DepositRequestsStartIndex           uint64                                  `json:"deposit_requests_start_index" yaml:"deposit_requests_start_index"`
-	DepositBalanceToConsume             primitives.Gwei                         `json:"deposit_balance_to_consume" yaml:"deposit_balance_to_consume"`
-	ExitBalanceToConsume                primitives.Gwei                         `json:"exit_balance_to_consume" yaml:"exit_balance_to_consume"`
-	EarliestExitEpoch                   primitives.Epoch                        `json:"earliest_exit_epoch" yaml:"earliest_exit_epoch"`
-	ConsolidationBalanceToConsume       primitives.Gwei                         `json:"consolidation_balance_to_consume" yaml:"consolidation_balance_to_consume"`
-	EarliestConsolidationEpoch          primitives.Epoch                        `json:"earliest_consolidation_epoch" yaml:"earliest_consolidation_epoch"`
-	PendingBalanceDeposits              []*ethpb.PendingBalanceDeposit          `json:"pending_balance_deposits" yaml:"pending_balance_deposits"`
-	PendingPartialWithdrawals           []*ethpb.PendingPartialWithdrawal       `json:"pending_partial_withdrawals" yaml:"pending_partial_withdrawals"`
-	PendingConsolidations               []*ethpb.PendingConsolidation           `json:"pending_consolidations" yaml:"pending_consolidations"`
-}
-
-func (b *BeaconState) MarshalJSON() ([]byte, error) {
-	var bRoots customtypes.BlockRoots
-	var sRoots customtypes.StateRoots
-	var mixes customtypes.RandaoMixes
-	var balances []uint64
-	var inactivityScores []uint64
-	var vals []*ethpb.Validator
-
-	if features.Get().EnableExperimentalState {
-		bRoots = b.blockRootsMultiValue.Value(b)
-		sRoots = b.stateRootsMultiValue.Value(b)
-		mixes = b.randaoMixesMultiValue.Value(b)
-		balances = b.balancesMultiValue.Value(b)
-		inactivityScores = b.inactivityScoresMultiValue.Value(b)
-		vals = b.validatorsMultiValue.Value(b)
-	} else {
-		bRoots = b.blockRoots
-		sRoots = b.stateRoots
-		mixes = b.randaoMixes
-		balances = b.balances
-		inactivityScores = b.inactivityScores
-		vals = b.validators
-	}
-
-	marshalable := &beaconStateMarshalable{
-		Version:                             b.version,
-		GenesisTime:                         b.genesisTime,
-		GenesisValidatorsRoot:               b.genesisValidatorsRoot,
-		Slot:                                b.slot,
-		Fork:                                b.fork,
-		LatestBlockHeader:                   b.latestBlockHeader,
-		BlockRoots:                          bRoots,
-		StateRoots:                          sRoots,
-		HistoricalRoots:                     b.historicalRoots,
-		HistoricalSummaries:                 b.historicalSummaries,
-		Eth1Data:                            b.eth1Data,
-		Eth1DataVotes:                       b.eth1DataVotes,
-		Eth1DepositIndex:                    b.eth1DepositIndex,
-		Validators:                          vals,
-		Balances:                            balances,
-		RandaoMixes:                         mixes,
-		Slashings:                           b.slashings,
-		PreviousEpochAttestations:           b.previousEpochAttestations,
-		CurrentEpochAttestations:            b.currentEpochAttestations,
-		PreviousEpochParticipation:          b.previousEpochParticipation,
-		CurrentEpochParticipation:           b.currentEpochParticipation,
-		JustificationBits:                   b.justificationBits,
-		PreviousJustifiedCheckpoint:         b.previousJustifiedCheckpoint,
-		CurrentJustifiedCheckpoint:          b.currentJustifiedCheckpoint,
-		FinalizedCheckpoint:                 b.finalizedCheckpoint,
-		InactivityScores:                    inactivityScores,
-		CurrentSyncCommittee:                b.currentSyncCommittee,
-		NextSyncCommittee:                   b.nextSyncCommittee,
-		LatestExecutionPayloadHeader:        b.latestExecutionPayloadHeader,
-		LatestExecutionPayloadHeaderCapella: b.latestExecutionPayloadHeaderCapella,
-		LatestExecutionPayloadHeaderDeneb:   b.latestExecutionPayloadHeaderDeneb,
-		LatestExecutionPayloadHeaderElectra: b.latestExecutionPayloadHeaderElectra,
-		NextWithdrawalIndex:                 b.nextWithdrawalIndex,
-		NextWithdrawalValidatorIndex:        b.nextWithdrawalValidatorIndex,
-		DepositRequestsStartIndex:           b.depositRequestsStartIndex,
-		DepositBalanceToConsume:             b.depositBalanceToConsume,
-		ExitBalanceToConsume:                b.exitBalanceToConsume,
-		EarliestExitEpoch:                   b.earliestExitEpoch,
-		ConsolidationBalanceToConsume:       b.consolidationBalanceToConsume,
-		EarliestConsolidationEpoch:          b.earliestConsolidationEpoch,
-		PendingBalanceDeposits:              b.pendingBalanceDeposits,
-		PendingPartialWithdrawals:           b.pendingPartialWithdrawals,
-		PendingConsolidations:               b.pendingConsolidations,
-	}
-	return json.Marshal(marshalable)
-}

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

@@ -30,8 +30,8 @@ func newFinalizedValidatorIndexCache() *finalizedValidatorIndexCache {
 // If the public key is not found in the cache, it searches through the state starting from the last finalized index.
 func (b *BeaconState) getValidatorIndex(pubKey [fieldparams.BLSPubkeyLength]byte) (primitives.ValidatorIndex, bool) {
 	b.validatorIndexCache.RLock()
+	defer b.validatorIndexCache.RUnlock()
 	index, found := b.validatorIndexCache.indexMap[pubKey]
-	b.validatorIndexCache.RUnlock()
 	if found {
 		return index, true
 	}

beacon-chain/sync/subscriber_beacon_attestation.go

@@ -25,7 +25,11 @@ func (s *Service) committeeIndexBeaconAttestationSubscriber(_ context.Context, m
 	if data == nil {
 		return errors.New("nil attestation")
 	}
-	s.setSeenCommitteeIndicesSlot(data.Slot, data.CommitteeIndex, a.GetAggregationBits())
+	committeeIndex, err := a.GetCommitteeIndex()
+	if err != nil {
+		return errors.Wrap(err, "committeeIndexBeaconAttestationSubscriber failed to get committee index")
+	}
+	s.setSeenCommitteeIndicesSlot(data.Slot, committeeIndex, a.GetAggregationBits())
 
 	exists, err := s.cfg.attPool.HasAggregatedAttestation(a)
 	if err != nil {

beacon-chain/sync/validate_aggregate_proof.go

@@ -167,39 +167,32 @@ func (s *Service) validateAggregatedAtt(ctx context.Context, signed ethpb.Signed
 		return pubsub.ValidationIgnore, err
 	}
 
+	committeeIndex, _, result, err := s.validateCommitteeIndexAndCount(ctx, aggregate, bs)
+	if result != pubsub.ValidationAccept {
+		wrappedErr := errors.Wrapf(err, "could not validate committee index")
+		tracing.AnnotateError(span, wrappedErr)
+		return result, err
+	}
+
+	committee, result, err := s.validateBitLength(ctx, bs, aggregate.GetData().Slot, committeeIndex, aggregate.GetAggregationBits())
+	if result != pubsub.ValidationAccept {
+		return result, err
+	}
+
 	// Verify validator index is within the beacon committee.
-	result, err := s.validateIndexInCommittee(ctx, bs, aggregate, aggregatorIndex)
+	result, err = s.validateIndexInCommittee(ctx, aggregate, aggregatorIndex, committee)
 	if result != pubsub.ValidationAccept {
 		wrappedErr := errors.Wrapf(err, "could not validate index in committee")
 		tracing.AnnotateError(span, wrappedErr)
 		return result, wrappedErr
 	}
 
-	var committeeIndex primitives.CommitteeIndex
-	if signed.Version() >= version.Electra {
-		a, ok := aggregate.(*ethpb.AttestationElectra)
-		// This will never fail in practice because we asserted the version
-		if !ok {
-			err := fmt.Errorf("aggregate attestation has wrong type (expected %T, got %T)", &ethpb.AttestationElectra{}, aggregate)
-			tracing.AnnotateError(span, err)
-			return pubsub.ValidationIgnore, err
-		}
-		committeeIndex, result, err = validateCommitteeIndexElectra(ctx, a)
-		if result != pubsub.ValidationAccept {
-			wrappedErr := errors.Wrapf(err, "could not validate committee index for Electra version")
-			tracing.AnnotateError(span, wrappedErr)
-			return result, wrappedErr
-		}
-	} else {
-		committeeIndex = data.CommitteeIndex
-	}
-
 	// Verify selection proof reflects to the right validator.
 	selectionSigSet, err := validateSelectionIndex(
 		ctx,
 		bs,
 		data.Slot,
-		committeeIndex,
+		committee,
 		aggregatorIndex,
 		aggregateAndProof.GetSelectionProof(),
 	)
@@ -266,20 +259,10 @@ func (s *Service) setAggregatorIndexEpochSeen(epoch primitives.Epoch, aggregator
 //   - [REJECT] The aggregate attestation has participants -- that is, len(get_attesting_indices(state, aggregate.data, aggregate.aggregation_bits)) >= 1.
 //   - [REJECT] The aggregator's validator index is within the committee --
 //     i.e. `aggregate_and_proof.aggregator_index in get_beacon_committee(state, aggregate.data.slot, aggregate.data.index)`.
-func (s *Service) validateIndexInCommittee(ctx context.Context, bs state.ReadOnlyBeaconState, a ethpb.Att, validatorIndex primitives.ValidatorIndex) (pubsub.ValidationResult, error) {
-	ctx, span := trace.StartSpan(ctx, "sync.validateIndexInCommittee")
+func (s *Service) validateIndexInCommittee(ctx context.Context, a ethpb.Att, validatorIndex primitives.ValidatorIndex, committee []primitives.ValidatorIndex) (pubsub.ValidationResult, error) {
+	_, span := trace.StartSpan(ctx, "sync.validateIndexInCommittee")
 	defer span.End()
 
-	_, result, err := s.validateCommitteeIndex(ctx, a, bs)
-	if result != pubsub.ValidationAccept {
-		return result, err
-	}
-
-	committee, result, err := s.validateBitLength(ctx, bs, a.GetData().Slot, a.GetData().CommitteeIndex, a.GetAggregationBits())
-	if result != pubsub.ValidationAccept {
-		return result, err
-	}
-
 	if a.GetAggregationBits().Count() == 0 {
 		return pubsub.ValidationReject, errors.New("no attesting indices")
 	}
@@ -304,17 +287,13 @@ func validateSelectionIndex(
 	ctx context.Context,
 	bs state.ReadOnlyBeaconState,
 	slot primitives.Slot,
-	committeeIndex primitives.CommitteeIndex,
+	committee []primitives.ValidatorIndex,
 	validatorIndex primitives.ValidatorIndex,
 	proof []byte,
 ) (*bls.SignatureBatch, error) {
-	ctx, span := trace.StartSpan(ctx, "sync.validateSelectionIndex")
+	_, span := trace.StartSpan(ctx, "sync.validateSelectionIndex")
 	defer span.End()
 
-	committee, err := helpers.BeaconCommitteeFromState(ctx, bs, slot, committeeIndex)
-	if err != nil {
-		return nil, err
-	}
 	aggregator, err := helpers.IsAggregator(uint64(len(committee)), proof)
 	if err != nil {
 		return nil, err

beacon-chain/sync/validate_aggregate_proof_test.go

@@ -44,20 +44,19 @@ func TestVerifyIndexInCommittee_CanVerify(t *testing.T) {
 
 	bf := bitfield.NewBitlist(validators / uint64(params.BeaconConfig().SlotsPerEpoch))
 	bf.SetBitAt(0, true)
-	att := &ethpb.Attestation{Data: &ethpb.AttestationData{
-		Target: &ethpb.Checkpoint{Epoch: 0}},
-		AggregationBits: bf}
+	att := &ethpb.Attestation{Data: &ethpb.AttestationData{}, AggregationBits: bf}
 
 	committee, err := helpers.BeaconCommitteeFromState(context.Background(), s, att.Data.Slot, att.Data.CommitteeIndex)
 	assert.NoError(t, err)
 	indices, err := attestation.AttestingIndices(att, committee)
 	require.NoError(t, err)
-	result, err := service.validateIndexInCommittee(ctx, s, att, primitives.ValidatorIndex(indices[0]))
+
+	result, err := service.validateIndexInCommittee(ctx, att, primitives.ValidatorIndex(indices[0]), committee)
 	require.NoError(t, err)
 	assert.Equal(t, pubsub.ValidationAccept, result)
 
 	wanted := "validator index 1000 is not within the committee"
-	result, err = service.validateIndexInCommittee(ctx, s, att, 1000)
+	result, err = service.validateIndexInCommittee(ctx, att, 1000, committee)
 	assert.ErrorContains(t, wanted, err)
 	assert.Equal(t, pubsub.ValidationReject, result)
 }
@@ -71,8 +70,7 @@ func TestVerifyIndexInCommittee_ExistsInBeaconCommittee(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, validators)
 	require.NoError(t, s.SetSlot(params.BeaconConfig().SlotsPerEpoch))
 
-	att := &ethpb.Attestation{Data: &ethpb.AttestationData{
-		Target: &ethpb.Checkpoint{Epoch: 0}}}
+	att := &ethpb.Attestation{Data: &ethpb.AttestationData{}}
 
 	committee, err := helpers.BeaconCommitteeFromState(context.Background(), s, att.Data.Slot, att.Data.CommitteeIndex)
 	require.NoError(t, err)
@@ -81,32 +79,52 @@ func TestVerifyIndexInCommittee_ExistsInBeaconCommittee(t *testing.T) {
 	att.AggregationBits = bl
 
 	service := &Service{}
-	result, err := service.validateIndexInCommittee(ctx, s, att, committee[0])
+	result, err := service.validateIndexInCommittee(ctx, att, committee[0], committee)
 	require.ErrorContains(t, "no attesting indices", err)
 	assert.Equal(t, pubsub.ValidationReject, result)
 
 	att.AggregationBits.SetBitAt(0, true)
 
-	result, err = service.validateIndexInCommittee(ctx, s, att, committee[0])
+	result, err = service.validateIndexInCommittee(ctx, att, committee[0], committee)
 	require.NoError(t, err)
 	assert.Equal(t, pubsub.ValidationAccept, result)
 
 	wanted := "validator index 1000 is not within the committee"
-	result, err = service.validateIndexInCommittee(ctx, s, att, 1000)
+	result, err = service.validateIndexInCommittee(ctx, att, 1000, committee)
 	assert.ErrorContains(t, wanted, err)
 	assert.Equal(t, pubsub.ValidationReject, result)
 
 	att.AggregationBits = bitfield.NewBitlist(1)
-	result, err = service.validateIndexInCommittee(ctx, s, att, committee[0])
+	committeeIndex, err := att.GetCommitteeIndex()
+	require.NoError(t, err)
+	_, result, err = service.validateBitLength(ctx, s, att.Data.Slot, committeeIndex, att.AggregationBits)
 	require.ErrorContains(t, "wanted participants bitfield length 4, got: 1", err)
 	assert.Equal(t, pubsub.ValidationReject, result)
 
 	att.Data.CommitteeIndex = 10000
-	result, err = service.validateIndexInCommittee(ctx, s, att, committee[0])
+	_, _, result, err = service.validateCommitteeIndexAndCount(ctx, att, s)
 	require.ErrorContains(t, "committee index 10000 > 2", err)
 	assert.Equal(t, pubsub.ValidationReject, result)
 }
 
+func TestVerifyIndexInCommittee_Electra(t *testing.T) {
+	ctx := context.Background()
+	s, _ := util.DeterministicGenesisStateElectra(t, 64)
+	service := &Service{}
+	cb := primitives.NewAttestationCommitteeBits()
+	cb.SetBitAt(0, true)
+	att := &ethpb.AttestationElectra{Data: &ethpb.AttestationData{}, CommitteeBits: cb}
+	committee, err := helpers.BeaconCommitteeFromState(context.Background(), s, att.Data.Slot, att.Data.CommitteeIndex)
+	require.NoError(t, err)
+	bl := bitfield.NewBitlist(uint64(len(committee)))
+	bl.SetBitAt(0, true)
+	att.AggregationBits = bl
+
+	result, err := service.validateIndexInCommittee(ctx, att, committee[0], committee)
+	require.NoError(t, err)
+	assert.Equal(t, pubsub.ValidationAccept, result)
+}
+
 func TestVerifySelection_NotAnAggregator(t *testing.T) {
 	ctx := context.Background()
 	params.SetupTestConfigCleanup(t)
@@ -116,8 +134,9 @@ func TestVerifySelection_NotAnAggregator(t *testing.T) {
 
 	sig := privKeys[0].Sign([]byte{'A'})
 	data := util.HydrateAttestationData(&ethpb.AttestationData{})
-
-	_, err := validateSelectionIndex(ctx, beaconState, data.Slot, data.CommitteeIndex, 0, sig.Marshal())
+	committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, data.Slot, data.CommitteeIndex)
+	require.NoError(t, err)
+	_, err = validateSelectionIndex(ctx, beaconState, data.Slot, committee, 0, sig.Marshal())
 	wanted := "validator is not an aggregator for slot"
 	assert.ErrorContains(t, wanted, err)
 }

beacon-chain/sync/validate_beacon_attestation.go

@@ -94,65 +94,26 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 
 	var validationRes pubsub.ValidationResult
 
-	var committeeIndex primitives.CommitteeIndex
-	if att.Version() >= version.Electra {
-		a, ok := att.(*eth.AttestationElectra)
-		// This will never fail in practice because we asserted the version
-		if !ok {
-			err := fmt.Errorf("attestation has wrong type (expected %T, got %T)", &eth.AttestationElectra{}, att)
-			tracing.AnnotateError(span, err)
-			return pubsub.ValidationIgnore, err
+	committeeIndex, result, err := s.validateCommitteeIndex(ctx, att)
+	if result != pubsub.ValidationAccept {
+		wrappedErr := errors.Wrapf(err, "could not validate committee index for %s version", version.String(att.Version()))
+		tracing.AnnotateError(span, wrappedErr)
+		return result, wrappedErr
+	}
+
+	if !features.Get().EnableSlasher {
+		// Verify this the first attestation received for the participating validator for the slot.
+		if s.hasSeenCommitteeIndicesSlot(data.Slot, committeeIndex, att.GetAggregationBits()) {
+			return pubsub.ValidationIgnore, nil
 		}
-		committeeIndex, validationRes, err = validateCommitteeIndexElectra(ctx, a)
-		if validationRes != pubsub.ValidationAccept {
-			wrappedErr := errors.Wrapf(err, "could not validate committee index for Electra version")
-			tracing.AnnotateError(span, wrappedErr)
-			return validationRes, wrappedErr
+
+		// Reject an attestation if it references an invalid block.
+		if s.hasBadBlock(bytesutil.ToBytes32(data.BeaconBlockRoot)) ||
+			s.hasBadBlock(bytesutil.ToBytes32(data.Target.Root)) ||
+			s.hasBadBlock(bytesutil.ToBytes32(data.Source.Root)) {
+			attBadBlockCount.Inc()
+			return pubsub.ValidationReject, errors.New("attestation data references bad block root")
 		}
-	} else {
-		committeeIndex = data.CommitteeIndex
-	}
-
-	if features.Get().EnableSlasher {
-		// Feed the indexed attestation to slasher if enabled. This action
-		// is done in the background to avoid adding more load to this critical code path.
-		go func() {
-			// Using a different context to prevent timeouts as this operation can be expensive
-			// and we want to avoid affecting the critical code path.
-			ctx := context.TODO()
-			preState, err := s.cfg.chain.AttestationTargetState(ctx, data.Target)
-			if err != nil {
-				log.WithError(err).Error("Could not retrieve pre state")
-				tracing.AnnotateError(span, err)
-				return
-			}
-			committee, err := helpers.BeaconCommitteeFromState(ctx, preState, data.Slot, committeeIndex)
-			if err != nil {
-				log.WithError(err).Error("Could not get attestation committee")
-				tracing.AnnotateError(span, err)
-				return
-			}
-			indexedAtt, err := attestation.ConvertToIndexed(ctx, att, committee)
-			if err != nil {
-				log.WithError(err).Error("Could not convert to indexed attestation")
-				tracing.AnnotateError(span, err)
-				return
-			}
-			s.cfg.slasherAttestationsFeed.Send(&types.WrappedIndexedAtt{IndexedAtt: indexedAtt})
-		}()
-	}
-
-	// Verify this the first attestation received for the participating validator for the slot.
-	if s.hasSeenCommitteeIndicesSlot(data.Slot, data.CommitteeIndex, att.GetAggregationBits()) {
-		return pubsub.ValidationIgnore, nil
-	}
-
-	// Reject an attestation if it references an invalid block.
-	if s.hasBadBlock(bytesutil.ToBytes32(data.BeaconBlockRoot)) ||
-		s.hasBadBlock(bytesutil.ToBytes32(data.Target.Root)) ||
-		s.hasBadBlock(bytesutil.ToBytes32(data.Source.Root)) {
-		attBadBlockCount.Inc()
-		return pubsub.ValidationReject, errors.New("attestation data references bad block root")
 	}
 
 	// Verify the block being voted and the processed state is in beaconDB and the block has passed validation if it's in the beaconDB.
@@ -203,7 +164,36 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 		return validationRes, err
 	}
 
-	s.setSeenCommitteeIndicesSlot(data.Slot, data.CommitteeIndex, att.GetAggregationBits())
+	if features.Get().EnableSlasher {
+		// Feed the indexed attestation to slasher if enabled. This action
+		// is done in the background to avoid adding more load to this critical code path.
+		go func() {
+			// Using a different context to prevent timeouts as this operation can be expensive
+			// and we want to avoid affecting the critical code path.
+			ctx := context.TODO()
+			preState, err := s.cfg.chain.AttestationTargetState(ctx, data.Target)
+			if err != nil {
+				log.WithError(err).Error("Could not retrieve pre state")
+				tracing.AnnotateError(span, err)
+				return
+			}
+			committee, err := helpers.BeaconCommitteeFromState(ctx, preState, data.Slot, committeeIndex)
+			if err != nil {
+				log.WithError(err).Error("Could not get attestation committee")
+				tracing.AnnotateError(span, err)
+				return
+			}
+			indexedAtt, err := attestation.ConvertToIndexed(ctx, att, committee)
+			if err != nil {
+				log.WithError(err).Error("Could not convert to indexed attestation")
+				tracing.AnnotateError(span, err)
+				return
+			}
+			s.cfg.slasherAttestationsFeed.Send(&types.WrappedIndexedAtt{IndexedAtt: indexedAtt})
+		}()
+	}
+
+	s.setSeenCommitteeIndicesSlot(data.Slot, committeeIndex, att.GetAggregationBits())
 
 	msg.ValidatorData = att
 
@@ -215,7 +205,7 @@ func (s *Service) validateUnaggregatedAttTopic(ctx context.Context, a eth.Att, b
 	ctx, span := trace.StartSpan(ctx, "sync.validateUnaggregatedAttTopic")
 	defer span.End()
 
-	valCount, result, err := s.validateCommitteeIndex(ctx, a, bs)
+	_, valCount, result, err := s.validateCommitteeIndexAndCount(ctx, a, bs)
 	if result != pubsub.ValidationAccept {
 		return result, err
 	}
@@ -233,16 +223,31 @@ func (s *Service) validateUnaggregatedAttTopic(ctx context.Context, a eth.Att, b
 	return pubsub.ValidationAccept, nil
 }
 
-func (s *Service) validateCommitteeIndex(ctx context.Context, a eth.Att, bs state.ReadOnlyBeaconState) (uint64, pubsub.ValidationResult, error) {
+func (s *Service) validateCommitteeIndexAndCount(
+	ctx context.Context,
+	a eth.Att,
+	bs state.ReadOnlyBeaconState,
+) (primitives.CommitteeIndex, uint64, pubsub.ValidationResult, error) {
+	ci, result, err := s.validateCommitteeIndex(ctx, a)
+	if result != pubsub.ValidationAccept {
+		return 0, 0, result, err
+	}
 	valCount, err := helpers.ActiveValidatorCount(ctx, bs, slots.ToEpoch(a.GetData().Slot))
 	if err != nil {
-		return 0, pubsub.ValidationIgnore, err
+		return 0, 0, pubsub.ValidationIgnore, err
 	}
 	count := helpers.SlotCommitteeCount(valCount)
-	if uint64(a.GetData().CommitteeIndex) > count {
-		return 0, pubsub.ValidationReject, errors.Errorf("committee index %d > %d", a.GetData().CommitteeIndex, count)
+	if uint64(ci) > count {
+		return 0, 0, pubsub.ValidationReject, fmt.Errorf("committee index %d > %d", a.GetData().CommitteeIndex, count)
 	}
-	return valCount, pubsub.ValidationAccept, nil
+	return ci, valCount, pubsub.ValidationAccept, nil
+}
+
+func (s *Service) validateCommitteeIndex(ctx context.Context, a eth.Att) (primitives.CommitteeIndex, pubsub.ValidationResult, error) {
+	if a.Version() >= version.Electra {
+		return validateCommitteeIndexElectra(ctx, a)
+	}
+	return a.GetData().CommitteeIndex, pubsub.ValidationAccept, nil
 }
 
 // This validates beacon unaggregated attestation using the given state, the validation consists of bitfield length and count consistency
@@ -251,7 +256,12 @@ func (s *Service) validateUnaggregatedAttWithState(ctx context.Context, a eth.At
 	ctx, span := trace.StartSpan(ctx, "sync.validateUnaggregatedAttWithState")
 	defer span.End()
 
-	committee, result, err := s.validateBitLength(ctx, bs, a.GetData().Slot, a.GetData().CommitteeIndex, a.GetAggregationBits())
+	committeeIndex, err := a.GetCommitteeIndex()
+	if err != nil {
+		return pubsub.ValidationIgnore, err
+	}
+
+	committee, result, err := s.validateBitLength(ctx, bs, a.GetData().Slot, committeeIndex, a.GetAggregationBits())
 	if result != pubsub.ValidationAccept {
 		return result, err
 	}

beacon-chain/sync/validate_beacon_attestation_electra.go

@@ -5,23 +5,24 @@ import (
 	"fmt"
 
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"go.opencensus.io/trace"
 )
 
-func validateCommitteeIndexElectra(ctx context.Context, a *ethpb.AttestationElectra) (primitives.CommitteeIndex, pubsub.ValidationResult, error) {
+// validateCommitteeIndexElectra implements the following checks from the spec:
+//   - [REJECT] len(committee_indices) == 1, where committee_indices = get_committee_indices(attestation).
+//   - [REJECT] attestation.data.index == 0
+func validateCommitteeIndexElectra(ctx context.Context, a ethpb.Att) (primitives.CommitteeIndex, pubsub.ValidationResult, error) {
 	_, span := trace.StartSpan(ctx, "sync.validateCommitteeIndexElectra")
 	defer span.End()
-
-	ci := a.Data.CommitteeIndex
-	if ci != 0 {
-		return 0, pubsub.ValidationReject, fmt.Errorf("committee index must be 0 but was %d", ci)
+	_, ok := a.(*ethpb.AttestationElectra)
+	if !ok {
+		return 0, pubsub.ValidationIgnore, fmt.Errorf("attestation has wrong type (expected %T, got %T)", &ethpb.AttestationElectra{}, a)
 	}
-	committeeIndices := helpers.CommitteeIndices(a.CommitteeBits)
-	if len(committeeIndices) != 1 {
-		return 0, pubsub.ValidationReject, fmt.Errorf("exactly 1 committee index must be set but %d were set", len(committeeIndices))
+	committeeIndex, err := a.GetCommitteeIndex()
+	if err != nil {
+		return 0, pubsub.ValidationReject, err
 	}
-	return committeeIndices[0], pubsub.ValidationAccept, nil
+	return committeeIndex, pubsub.ValidationAccept, nil
 }

config/fieldparams/mainnet.go

@@ -39,4 +39,12 @@ const (
 	MaxDepositRequestsPerPayload          = 8192          // Maximum number of deposit requests in an execution payload.
 	MaxWithdrawalRequestsPerPayload       = 16            // Maximum number of execution layer withdrawal requests in an execution payload.
 	MaxConsolidationRequestsPerPayload    = 1             // Maximum number of consolidation requests in an execution payload.
+	MaxProposerSlashings                  = 16            // Maximum number of proposer slashings in a block.
+	MaxAttesterSlashings                  = 2             // Maximum number of attester slashings in a block.
+	MaxAttesterSlashingsElectra           = 1             // Maximum number of attester slashings in a block.
+	MaxAttestations                       = 128           // Maximum number of attestations in a block.
+	MaxAttestationsElectra                = 8             // Maximum number of attestations in a block.
+	MaxDeposits                           = 16            // Maximum number of deposits in a block.
+	MaxVoluntaryExits                     = 16            // Maximum number of voluntary exits in a block.
+	MaxBlsToExecutionChanges              = 16            // Maximum number of bls to execution changes in a block.
 )

config/fieldparams/minimal.go

@@ -39,4 +39,12 @@ const (
 	MaxDepositRequestsPerPayload          = 4             // Maximum number of deposit requests in an execution payload.
 	MaxWithdrawalRequestsPerPayload       = 2             // Maximum number of execution layer withdrawal requests in an execution payload.
 	MaxConsolidationRequestsPerPayload    = 1             // Maximum number of consolidation requests in an execution payload.
+	MaxProposerSlashings                  = 16            // Maximum number of proposer slashings in a block.
+	MaxAttesterSlashings                  = 2             // Maximum number of attester slashings in a block.
+	MaxAttesterSlashingsElectra           = 1             // Maximum number of attester slashings in a block.
+	MaxAttestations                       = 128           // Maximum number of attestations in a block.
+	MaxAttestationsElectra                = 8             // Maximum number of attestations in a block.
+	MaxDeposits                           = 16            // Maximum number of deposits in a block.
+	MaxVoluntaryExits                     = 16            // Maximum number of voluntary exits in a block.
+	MaxBlsToExecutionChanges              = 16            // Maximum number of bls to execution changes in a block.
 )

config/params/loader.go

@@ -233,8 +233,6 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("MESSAGE_DOMAIN_INVALID_SNAPPY:  %#x", cfg.MessageDomainInvalidSnappy),
 		fmt.Sprintf("MESSAGE_DOMAIN_VALID_SNAPPY: %#x", cfg.MessageDomainValidSnappy),
 		fmt.Sprintf("MIN_EPOCHS_FOR_BLOCK_REQUESTS: %d", int(cfg.MinEpochsForBlockRequests)),
-		fmt.Sprintf("ELECTRA_FORK_EPOCH: %d", cfg.ElectraForkEpoch),
-		fmt.Sprintf("ELECTRA_FORK_VERSION: %#x", cfg.ElectraForkVersion),
 	}
 
 	yamlFile := []byte(strings.Join(lines, "\n"))

config/params/loader_test.go

@@ -32,6 +32,8 @@ var placeholderFields = []string{
 	"EIP7002_FORK_VERSION",
 	"EIP7594_FORK_EPOCH",
 	"EIP7594_FORK_VERSION",
+	"EIP7732_FORK_EPOCH",
+	"EIP7732_FORK_VERSION",
 	"FIELD_ELEMENTS_PER_BLOB",              // Compile time constant.
 	"KZG_COMMITMENT_INCLUSION_PROOF_DEPTH", // Compile time constant on BlobSidecar.commitment_inclusion_proof.
 	"MAX_BLOBS_PER_BLOCK",

config/params/minimal_config.go

@@ -70,6 +70,7 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	minimalConfig.MaxDeposits = 16
 	minimalConfig.MaxVoluntaryExits = 16
 	minimalConfig.MaxWithdrawalsPerPayload = 4
+	minimalConfig.MaxBlsToExecutionChanges = 16
 	minimalConfig.MaxValidatorsPerWithdrawalsSweep = 16
 
 	// Signature domains

consensus-types/blocks/BUILD.bazel

@@ -8,6 +8,7 @@ go_library(
         "get_payload.go",
         "getters.go",
         "kzg.go",
+        "proofs.go",
         "proto.go",
         "roblob.go",
         "roblock.go",
@@ -23,6 +24,7 @@ go_library(
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/trie:go_default_library",
+        "//crypto/hash/htr:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz:go_default_library",
         "//proto/engine/v1:go_default_library",
@@ -32,6 +34,7 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_prysmaticlabs_gohashtree//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
@@ -43,6 +46,7 @@ go_test(
         "factory_test.go",
         "getters_test.go",
         "kzg_test.go",
+        "proofs_test.go",
         "proto_test.go",
         "roblob_test.go",
         "roblock_test.go",

consensus-types/blocks/getters_test.go

@@ -503,6 +503,135 @@ func hydrateBeaconBlockBody() *eth.BeaconBlockBody {
 	}
 }
 
+func hydrateBeaconBlockBodyAltair() *eth.BeaconBlockBodyAltair {
+	return &eth.BeaconBlockBodyAltair{
+		RandaoReveal: make([]byte, fieldparams.BLSSignatureLength),
+		Graffiti:     make([]byte, fieldparams.RootLength),
+		Eth1Data: &eth.Eth1Data{
+			DepositRoot: make([]byte, fieldparams.RootLength),
+			BlockHash:   make([]byte, fieldparams.RootLength),
+		},
+		SyncAggregate: &eth.SyncAggregate{
+			SyncCommitteeBits:      make([]byte, 64),
+			SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
+		},
+	}
+}
+
+func hydrateBeaconBlockBodyBellatrix() *eth.BeaconBlockBodyBellatrix {
+	return &eth.BeaconBlockBodyBellatrix{
+		RandaoReveal: make([]byte, fieldparams.BLSSignatureLength),
+		Graffiti:     make([]byte, fieldparams.RootLength),
+		Eth1Data: &eth.Eth1Data{
+			DepositRoot: make([]byte, fieldparams.RootLength),
+			BlockHash:   make([]byte, fieldparams.RootLength),
+		},
+		SyncAggregate: &eth.SyncAggregate{
+			SyncCommitteeBits:      make([]byte, 64),
+			SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
+		},
+		ExecutionPayload: &pb.ExecutionPayload{
+			ParentHash:    make([]byte, fieldparams.RootLength),
+			FeeRecipient:  make([]byte, 20),
+			StateRoot:     make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+			LogsBloom:     make([]byte, 256),
+			PrevRandao:    make([]byte, fieldparams.RootLength),
+			ExtraData:     make([]byte, 0),
+			BaseFeePerGas: make([]byte, fieldparams.RootLength),
+			BlockHash:     make([]byte, fieldparams.RootLength),
+			Transactions:  make([][]byte, 0),
+		},
+	}
+}
+
+func hydrateBeaconBlockBodyCapella() *eth.BeaconBlockBodyCapella {
+	return &eth.BeaconBlockBodyCapella{
+		RandaoReveal: make([]byte, fieldparams.BLSSignatureLength),
+		Graffiti:     make([]byte, fieldparams.RootLength),
+		Eth1Data: &eth.Eth1Data{
+			DepositRoot: make([]byte, fieldparams.RootLength),
+			BlockHash:   make([]byte, fieldparams.RootLength),
+		},
+		SyncAggregate: &eth.SyncAggregate{
+			SyncCommitteeBits:      make([]byte, fieldparams.SyncAggregateSyncCommitteeBytesLength),
+			SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
+		},
+		ExecutionPayload: &pb.ExecutionPayloadCapella{
+			ParentHash:    make([]byte, fieldparams.RootLength),
+			FeeRecipient:  make([]byte, 20),
+			StateRoot:     make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+			LogsBloom:     make([]byte, 256),
+			PrevRandao:    make([]byte, fieldparams.RootLength),
+			ExtraData:     make([]byte, 0),
+			BaseFeePerGas: make([]byte, fieldparams.RootLength),
+			BlockHash:     make([]byte, fieldparams.RootLength),
+			Transactions:  make([][]byte, 0),
+			Withdrawals:   make([]*pb.Withdrawal, 0),
+		},
+	}
+}
+
+func hydrateBeaconBlockBodyDeneb() *eth.BeaconBlockBodyDeneb {
+	return &eth.BeaconBlockBodyDeneb{
+		RandaoReveal: make([]byte, fieldparams.BLSSignatureLength),
+		Graffiti:     make([]byte, fieldparams.RootLength),
+		Eth1Data: &eth.Eth1Data{
+			DepositRoot: make([]byte, fieldparams.RootLength),
+			BlockHash:   make([]byte, fieldparams.RootLength),
+		},
+		SyncAggregate: &eth.SyncAggregate{
+			SyncCommitteeBits:      make([]byte, fieldparams.SyncAggregateSyncCommitteeBytesLength),
+			SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
+		},
+		ExecutionPayload: &pb.ExecutionPayloadDeneb{
+			ParentHash:    make([]byte, fieldparams.RootLength),
+			FeeRecipient:  make([]byte, 20),
+			StateRoot:     make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+			LogsBloom:     make([]byte, 256),
+			PrevRandao:    make([]byte, fieldparams.RootLength),
+			ExtraData:     make([]byte, 0),
+			BaseFeePerGas: make([]byte, fieldparams.RootLength),
+			BlockHash:     make([]byte, fieldparams.RootLength),
+			Transactions:  make([][]byte, 0),
+			Withdrawals:   make([]*pb.Withdrawal, 0),
+		},
+	}
+}
+
+func hydrateBeaconBlockBodyElectra() *eth.BeaconBlockBodyElectra {
+	return &eth.BeaconBlockBodyElectra{
+		RandaoReveal: make([]byte, fieldparams.BLSSignatureLength),
+		Graffiti:     make([]byte, fieldparams.RootLength),
+		Eth1Data: &eth.Eth1Data{
+			DepositRoot: make([]byte, fieldparams.RootLength),
+			BlockHash:   make([]byte, fieldparams.RootLength),
+		},
+		SyncAggregate: &eth.SyncAggregate{
+			SyncCommitteeBits:      make([]byte, fieldparams.SyncAggregateSyncCommitteeBytesLength),
+			SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
+		},
+		ExecutionPayload: &pb.ExecutionPayloadElectra{
+			ParentHash:            make([]byte, fieldparams.RootLength),
+			FeeRecipient:          make([]byte, 20),
+			StateRoot:             make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:          make([]byte, fieldparams.RootLength),
+			LogsBloom:             make([]byte, 256),
+			PrevRandao:            make([]byte, fieldparams.RootLength),
+			ExtraData:             make([]byte, 0),
+			BaseFeePerGas:         make([]byte, fieldparams.RootLength),
+			BlockHash:             make([]byte, fieldparams.RootLength),
+			Transactions:          make([][]byte, 0),
+			Withdrawals:           make([]*pb.Withdrawal, 0),
+			DepositRequests:       make([]*pb.DepositRequest, 0),
+			WithdrawalRequests:    make([]*pb.WithdrawalRequest, 0),
+			ConsolidationRequests: make([]*pb.ConsolidationRequest, 0),
+		},
+	}
+}
+
 func TestPreElectraFailsInterfaceAssertion(t *testing.T) {
 	var epd interfaces.ExecutionData = &executionPayloadDeneb{}
 	_, ok := epd.(interfaces.ExecutionDataElectra)

consensus-types/blocks/proofs.go

@@ -0,0 +1,174 @@
+package blocks
+
+import (
+	"context"
+	"encoding/binary"
+	"fmt"
+
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/crypto/hash/htr"
+	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"go.opencensus.io/trace"
+)
+
+func ComputeBlockBodyFieldRoots(ctx context.Context, blockBody *BeaconBlockBody) ([][]byte, error) {
+	_, span := trace.StartSpan(ctx, "blocks.ComputeBlockBodyFieldRoots")
+	defer span.End()
+
+	if blockBody == nil {
+		return nil, errNilBlockBody
+	}
+
+	var fieldRoots [][]byte
+	switch blockBody.version {
+	case version.Phase0:
+		fieldRoots = make([][]byte, 8)
+	case version.Altair:
+		fieldRoots = make([][]byte, 9)
+	case version.Bellatrix:
+		fieldRoots = make([][]byte, 10)
+	case version.Capella:
+		fieldRoots = make([][]byte, 11)
+	case version.Deneb:
+		fieldRoots = make([][]byte, 12)
+	case version.Electra:
+		fieldRoots = make([][]byte, 12)
+	default:
+		return nil, fmt.Errorf("unknown block body version %s", version.String(blockBody.version))
+	}
+
+	for i := range fieldRoots {
+		fieldRoots[i] = make([]byte, 32)
+	}
+
+	// Randao Reveal
+	randao := blockBody.RandaoReveal()
+	root, err := ssz.MerkleizeByteSliceSSZ(randao[:])
+	if err != nil {
+		return nil, err
+	}
+	copy(fieldRoots[0], root[:])
+
+	// eth1_data
+	eth1 := blockBody.Eth1Data()
+	root, err = eth1.HashTreeRoot()
+	if err != nil {
+		return nil, err
+	}
+	copy(fieldRoots[1], root[:])
+
+	// graffiti
+	root = blockBody.Graffiti()
+	copy(fieldRoots[2], root[:])
+
+	// Proposer slashings
+	ps := blockBody.ProposerSlashings()
+	root, err = ssz.MerkleizeListSSZ(ps, params.BeaconConfig().MaxProposerSlashings)
+	if err != nil {
+		return nil, err
+	}
+	copy(fieldRoots[3], root[:])
+
+	// Attester slashings
+	as := blockBody.AttesterSlashings()
+	bodyVersion := blockBody.Version()
+	if bodyVersion < version.Electra {
+		root, err = ssz.MerkleizeListSSZ(as, params.BeaconConfig().MaxAttesterSlashings)
+	} else {
+		root, err = ssz.MerkleizeListSSZ(as, params.BeaconConfig().MaxAttesterSlashingsElectra)
+	}
+	if err != nil {
+		return nil, err
+	}
+	copy(fieldRoots[4], root[:])
+
+	// Attestations
+	att := blockBody.Attestations()
+	if bodyVersion < version.Electra {
+		root, err = ssz.MerkleizeListSSZ(att, params.BeaconConfig().MaxAttestations)
+	} else {
+		root, err = ssz.MerkleizeListSSZ(att, params.BeaconConfig().MaxAttestationsElectra)
+	}
+	if err != nil {
+		return nil, err
+	}
+	copy(fieldRoots[5], root[:])
+
+	// Deposits
+	dep := blockBody.Deposits()
+	root, err = ssz.MerkleizeListSSZ(dep, params.BeaconConfig().MaxDeposits)
+	if err != nil {
+		return nil, err
+	}
+	copy(fieldRoots[6], root[:])
+
+	// Voluntary Exits
+	ve := blockBody.VoluntaryExits()
+	root, err = ssz.MerkleizeListSSZ(ve, params.BeaconConfig().MaxVoluntaryExits)
+	if err != nil {
+		return nil, err
+	}
+	copy(fieldRoots[7], root[:])
+
+	if blockBody.version >= version.Altair {
+		// Sync Aggregate
+		sa, err := blockBody.SyncAggregate()
+		if err != nil {
+			return nil, err
+		}
+		root, err = sa.HashTreeRoot()
+		if err != nil {
+			return nil, err
+		}
+		copy(fieldRoots[8], root[:])
+	}
+
+	if blockBody.version >= version.Bellatrix {
+		// Execution Payload
+		ep, err := blockBody.Execution()
+		if err != nil {
+			return nil, err
+		}
+		root, err = ep.HashTreeRoot()
+		if err != nil {
+			return nil, err
+		}
+		copy(fieldRoots[9], root[:])
+	}
+
+	if blockBody.version >= version.Capella {
+		// BLS Changes
+		bls, err := blockBody.BLSToExecutionChanges()
+		if err != nil {
+			return nil, err
+		}
+		root, err = ssz.MerkleizeListSSZ(bls, params.BeaconConfig().MaxBlsToExecutionChanges)
+		if err != nil {
+			return nil, err
+		}
+		copy(fieldRoots[10], root[:])
+	}
+
+	if blockBody.version >= version.Deneb {
+		// KZG commitments
+		roots := make([][32]byte, len(blockBody.blobKzgCommitments))
+		for i, commitment := range blockBody.blobKzgCommitments {
+			chunks, err := ssz.PackByChunk([][]byte{commitment})
+			if err != nil {
+				return nil, err
+			}
+			roots[i] = htr.VectorizedSha256(chunks)[0]
+		}
+		commitmentsRoot, err := ssz.BitwiseMerkleize(roots, uint64(len(roots)), 4096)
+		if err != nil {
+			return nil, err
+		}
+		length := make([]byte, 32)
+		binary.LittleEndian.PutUint64(length[:8], uint64(len(roots)))
+		root = ssz.MixInLength(commitmentsRoot, length)
+		copy(fieldRoots[11], root[:])
+	}
+
+	return fieldRoots, nil
+}

consensus-types/blocks/proofs_test.go

@@ -0,0 +1,147 @@
+package blocks
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/container/trie"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestComputeBlockBodyFieldRoots_Phase0(t *testing.T) {
+	blockBodyPhase0 := hydrateBeaconBlockBody()
+	i, err := NewBeaconBlockBody(blockBodyPhase0)
+	require.NoError(t, err)
+
+	b, ok := i.(*BeaconBlockBody)
+	require.Equal(t, true, ok)
+
+	fieldRoots, err := ComputeBlockBodyFieldRoots(context.Background(), b)
+	require.NoError(t, err)
+	trie, err := trie.GenerateTrieFromItems(fieldRoots, 3)
+	require.NoError(t, err)
+	layers := trie.ToProto().GetLayers()
+
+	hash := layers[len(layers)-1].Layer[0]
+	require.NoError(t, err)
+
+	correctHash, err := b.HashTreeRoot()
+	require.NoError(t, err)
+
+	require.DeepEqual(t, correctHash[:], hash)
+}
+
+func TestComputeBlockBodyFieldRoots_Altair(t *testing.T) {
+	blockBodyAltair := hydrateBeaconBlockBodyAltair()
+	i, err := NewBeaconBlockBody(blockBodyAltair)
+	require.NoError(t, err)
+
+	b, ok := i.(*BeaconBlockBody)
+	require.Equal(t, true, ok)
+
+	fieldRoots, err := ComputeBlockBodyFieldRoots(context.Background(), b)
+	require.NoError(t, err)
+	trie, err := trie.GenerateTrieFromItems(fieldRoots, 4)
+	require.NoError(t, err)
+	layers := trie.ToProto().GetLayers()
+
+	hash := layers[len(layers)-1].Layer[0]
+	require.NoError(t, err)
+
+	correctHash, err := b.HashTreeRoot()
+	require.NoError(t, err)
+
+	require.DeepEqual(t, correctHash[:], hash)
+}
+
+func TestComputeBlockBodyFieldRoots_Bellatrix(t *testing.T) {
+	blockBodyBellatrix := hydrateBeaconBlockBodyBellatrix()
+	i, err := NewBeaconBlockBody(blockBodyBellatrix)
+	require.NoError(t, err)
+
+	b, ok := i.(*BeaconBlockBody)
+	require.Equal(t, true, ok)
+
+	fieldRoots, err := ComputeBlockBodyFieldRoots(context.Background(), b)
+	require.NoError(t, err)
+	trie, err := trie.GenerateTrieFromItems(fieldRoots, 4)
+	require.NoError(t, err)
+	layers := trie.ToProto().GetLayers()
+
+	hash := layers[len(layers)-1].Layer[0]
+	require.NoError(t, err)
+
+	correctHash, err := b.HashTreeRoot()
+	require.NoError(t, err)
+
+	require.DeepEqual(t, correctHash[:], hash)
+}
+
+func TestComputeBlockBodyFieldRoots_Capella(t *testing.T) {
+	blockBodyCapella := hydrateBeaconBlockBodyCapella()
+	i, err := NewBeaconBlockBody(blockBodyCapella)
+	require.NoError(t, err)
+
+	b, ok := i.(*BeaconBlockBody)
+	require.Equal(t, true, ok)
+
+	fieldRoots, err := ComputeBlockBodyFieldRoots(context.Background(), b)
+	require.NoError(t, err)
+	trie, err := trie.GenerateTrieFromItems(fieldRoots, 4)
+	require.NoError(t, err)
+	layers := trie.ToProto().GetLayers()
+
+	hash := layers[len(layers)-1].Layer[0]
+	require.NoError(t, err)
+
+	correctHash, err := b.HashTreeRoot()
+	require.NoError(t, err)
+
+	require.DeepEqual(t, correctHash[:], hash)
+}
+
+func TestComputeBlockBodyFieldRoots_Deneb(t *testing.T) {
+	blockBodyDeneb := hydrateBeaconBlockBodyDeneb()
+	i, err := NewBeaconBlockBody(blockBodyDeneb)
+	require.NoError(t, err)
+
+	b, ok := i.(*BeaconBlockBody)
+	require.Equal(t, true, ok)
+
+	fieldRoots, err := ComputeBlockBodyFieldRoots(context.Background(), b)
+	require.NoError(t, err)
+	trie, err := trie.GenerateTrieFromItems(fieldRoots, 4)
+	require.NoError(t, err)
+	layers := trie.ToProto().GetLayers()
+
+	hash := layers[len(layers)-1].Layer[0]
+	require.NoError(t, err)
+
+	correctHash, err := b.HashTreeRoot()
+	require.NoError(t, err)
+
+	require.DeepEqual(t, correctHash[:], hash)
+}
+
+func TestComputeBlockBodyFieldRoots_Electra(t *testing.T) {
+	blockBodyElectra := hydrateBeaconBlockBodyElectra()
+	i, err := NewBeaconBlockBody(blockBodyElectra)
+	require.NoError(t, err)
+
+	b, ok := i.(*BeaconBlockBody)
+	require.Equal(t, true, ok)
+
+	fieldRoots, err := ComputeBlockBodyFieldRoots(context.Background(), b)
+	require.NoError(t, err)
+	trie, err := trie.GenerateTrieFromItems(fieldRoots, 4)
+	require.NoError(t, err)
+	layers := trie.ToProto().GetLayers()
+
+	hash := layers[len(layers)-1].Layer[0]
+	require.NoError(t, err)
+
+	correctHash, err := b.HashTreeRoot()
+	require.NoError(t, err)
+
+	require.DeepEqual(t, correctHash[:], hash)
+}

crypto/hash/hashtree/BUILD.bazel

@@ -0,0 +1,17 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["hashtree.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5/crypto/hash/hashtree",
+    visibility = ["//visibility:public"],
+    deps = ["@com_github_prysmaticlabs_hashtree//:go_default_library"],
+)
+
+go_test(
+    name = "go_default_test",
+    size = "small",
+    srcs = ["hashtree_test.go"],
+    embed = [":go_default_library"],
+    deps = ["//testing/require:go_default_library"],
+)

crypto/hash/hashtree/hashtree.go

@@ -0,0 +1,47 @@
+package hashtree
+
+import (
+	"runtime"
+	"sync"
+
+	"github.com/prysmaticlabs/hashtree"
+)
+
+const minSliceSizeToParallelize = 5000
+
+func hashParallel(inputList [][32]byte, outputList [][32]byte, wg *sync.WaitGroup) {
+	defer wg.Done()
+	err := hashtree.Hash(outputList, inputList)
+	if err != nil {
+		panic(err)
+	}
+}
+
+// VectorizedSha256 takes a list of roots and hashes them using CPU
+// specific vector instructions. Depending on host machine's specific
+// hardware configuration, using this routine can lead to a significant
+// performance improvement compared to the default method of hashing
+// lists.
+func VectorizedSha256(inputList [][32]byte) [][32]byte {
+	outputList := make([][32]byte, len(inputList)/2)
+	if len(inputList) < minSliceSizeToParallelize {
+		err := hashtree.Hash(outputList, inputList)
+		if err != nil {
+			panic(err)
+		}
+		return outputList
+	}
+	n := runtime.GOMAXPROCS(0) - 1
+	wg := sync.WaitGroup{}
+	wg.Add(n)
+	groupSize := len(inputList) / (2 * (n + 1))
+	for j := 0; j < n; j++ {
+		go hashParallel(inputList[j*2*groupSize:(j+1)*2*groupSize], outputList[j*groupSize:], &wg)
+	}
+	err := hashtree.Hash(outputList[n*groupSize:], inputList[n*2*groupSize:])
+	if err != nil {
+		panic(err)
+	}
+	wg.Wait()
+	return outputList
+}

crypto/hash/hashtree/hashtree_test.go

@@ -0,0 +1,27 @@
+package hashtree
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func Test_VectorizedSha256(t *testing.T) {
+	largeSlice := make([][32]byte, 32*minSliceSizeToParallelize)
+	secondLargeSlice := make([][32]byte, 32*minSliceSizeToParallelize)
+	hash1 := make([][32]byte, 16*minSliceSizeToParallelize)
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		tempHash := VectorizedSha256(largeSlice)
+		copy(hash1, tempHash)
+	}()
+	wg.Wait()
+	hash2 := VectorizedSha256(secondLargeSlice)
+	require.Equal(t, len(hash1), len(hash2))
+	for i, r := range hash1 {
+		require.Equal(t, r, hash2[i])
+	}
+}

proto/prysm/v1alpha1/BUILD.bazel

@@ -332,6 +332,7 @@ go_library(
         "//proto/engine/v1:go_default_library",
         "//proto/eth/ext:go_default_library",
         "//runtime/version:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
         "@com_github_golang_protobuf//proto:go_default_library",
         "@com_github_grpc_ecosystem_grpc_gateway_v2//protoc-gen-openapiv2/options:options_go_proto",
         "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",

proto/prysm/v1alpha1/attestation.go

@@ -1,6 +1,9 @@
 package eth
 
 import (
+	"fmt"
+
+	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -21,6 +24,7 @@ type Att interface {
 	GetData() *AttestationData
 	CommitteeBitsVal() bitfield.Bitfield
 	GetSignature() []byte
+	GetCommitteeIndex() (primitives.CommitteeIndex, error)
 }
 
 // IndexedAtt defines common functionality for all indexed attestation types.
@@ -123,6 +127,14 @@ func (a *Attestation) CommitteeBitsVal() bitfield.Bitfield {
 	return cb
 }
 
+// GetCommitteeIndex --
+func (a *Attestation) GetCommitteeIndex() (primitives.CommitteeIndex, error) {
+	if a == nil || a.Data == nil {
+		return 0, errors.New("nil attestation data")
+	}
+	return a.Data.CommitteeIndex, nil
+}
+
 // Version --
 func (a *PendingAttestation) Version() int {
 	return version.Phase0
@@ -156,6 +168,14 @@ func (a *PendingAttestation) GetSignature() []byte {
 	return nil
 }
 
+// GetCommitteeIndex --
+func (a *PendingAttestation) GetCommitteeIndex() (primitives.CommitteeIndex, error) {
+	if a == nil || a.Data == nil {
+		return 0, errors.New("nil attestation data")
+	}
+	return a.Data.CommitteeIndex, nil
+}
+
 // Version --
 func (a *AttestationElectra) Version() int {
 	return version.Electra
@@ -184,6 +204,24 @@ func (a *AttestationElectra) CommitteeBitsVal() bitfield.Bitfield {
 	return a.CommitteeBits
 }
 
+// GetCommitteeIndex --
+func (a *AttestationElectra) GetCommitteeIndex() (primitives.CommitteeIndex, error) {
+	if a == nil || a.Data == nil {
+		return 0, errors.New("nil attestation data")
+	}
+	if len(a.CommitteeBits) == 0 {
+		return 0, errors.New("no committee bits found in attestation")
+	}
+	if a.Data.CommitteeIndex != 0 {
+		return 0, fmt.Errorf("attestation data's committee index must be 0 but was %d", a.Data.CommitteeIndex)
+	}
+	indices := a.CommitteeBits.BitIndices()
+	if len(indices) != 1 {
+		return 0, fmt.Errorf("exactly 1 committee index must be set but %d were set", len(indices))
+	}
+	return primitives.CommitteeIndex(uint64(indices[0])), nil
+}
+
 // Version --
 func (a *IndexedAttestation) Version() int {
 	return version.Phase0

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

@@ -17,21 +17,13 @@ go_library(
     visibility = ["//testing/spectest:__subpackages__"],
     deps = [
         "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/blocks:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/validators: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",
-        "//testing/require:go_default_library",
-        "//testing/spectest/utils:go_default_library",
+        "//runtime/version:go_default_library",
+        "//testing/spectest/shared/common/operations:go_default_library",
         "//testing/util:go_default_library",
-        "@com_github_golang_snappy//:go_default_library",
-        "@com_github_google_go_cmp//cmp:go_default_library",
-        "@io_bazel_rules_go//go/tools/bazel:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-        "@org_golang_google_protobuf//testing/protocmp:go_default_library",
     ],
 )

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

@@ -1,59 +1,27 @@
 package operations
 
 import (
-	"context"
-	"errors"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	b "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunAttestationTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "altair", "operations/attestation/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "altair", "operations/attestation/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			attestationFile, err := util.BazelFileBytes(folderPath, "attestation.ssz_snappy")
-			require.NoError(t, err)
-			attestationSSZ, err := snappy.Decode(nil /* dst */, attestationFile)
-			require.NoError(t, err, "Failed to decompress")
-			att := &ethpb.Attestation{}
-			require.NoError(t, att.UnmarshalSSZ(attestationSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyAltair{Attestations: []*ethpb.Attestation{att}}
-			processAtt := func(ctx context.Context, st state.BeaconState, blk interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				st, err = altair.ProcessAttestationsNoVerifySignature(ctx, st, blk.Block())
-				if err != nil {
-					return nil, err
-				}
-				aSet, err := b.AttestationSignatureBatch(ctx, st, blk.Block().Body().Attestations())
-				if err != nil {
-					return nil, err
-				}
-				verified, err := aSet.Verify()
-				if err != nil {
-					return nil, err
-				}
-				if !verified {
-					return nil, errors.New("could not batch verify attestation signature")
-				}
-				return st, nil
-			}
-
-			RunBlockOperationTest(t, folderPath, body, processAtt)
-		})
+func blockWithAttestation(attestationSSZ []byte) (interfaces.SignedBeaconBlock, error) {
+	att := &ethpb.Attestation{}
+	if err := att.UnmarshalSSZ(attestationSSZ); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockAltair()
+	b.Block.Body = &ethpb.BeaconBlockBodyAltair{Attestations: []*ethpb.Attestation{att}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunAttestationTest(t *testing.T, config string) {
+	common.RunAttestationTest(t, config, version.String(version.Altair), blockWithAttestation, altair.ProcessAttestationsNoVerifySignature, sszToState)
 }

testing/spectest/shared/altair/operations/attester_slashing.go

@@ -1,41 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunAttesterSlashingTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "altair", "operations/attester_slashing/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "altair", "operations/attester_slashing/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			attSlashingFile, err := util.BazelFileBytes(folderPath, "attester_slashing.ssz_snappy")
-			require.NoError(t, err)
-			attSlashingSSZ, err := snappy.Decode(nil /* dst */, attSlashingFile)
-			require.NoError(t, err, "Failed to decompress")
-			attSlashing := &ethpb.AttesterSlashing{}
-			require.NoError(t, attSlashing.UnmarshalSSZ(attSlashingSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyAltair{AttesterSlashings: []*ethpb.AttesterSlashing{attSlashing}}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return blocks.ProcessAttesterSlashings(ctx, s, b.Block().Body().AttesterSlashings(), validators.SlashValidator)
-			})
-		})
+func blockWithAttesterSlashing(asSSZ []byte) (interfaces.SignedBeaconBlock, error) {
+	as := &ethpb.AttesterSlashing{}
+	if err := as.UnmarshalSSZ(asSSZ); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockAltair()
+	b.Block.Body = &ethpb.BeaconBlockBodyAltair{AttesterSlashings: []*ethpb.AttesterSlashing{as}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunAttesterSlashingTest(t *testing.T, config string) {
+	common.RunAttesterSlashingTest(t, config, version.String(version.Altair), blockWithAttesterSlashing, sszToState)
 }

testing/spectest/shared/altair/operations/block_header.go

@@ -1,90 +1,12 @@
 package operations
 
 import (
-	"context"
-	"os"
-	"path"
-	"strings"
 	"testing"
 
-	"github.com/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/golang/snappy"
-	"github.com/google/go-cmp/cmp"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/testing/protocmp"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 )
 
 func RunBlockHeaderTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "altair", "operations/block_header/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "altair", "operations/block_header/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			helpers.ClearCache()
-
-			blockFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "block.ssz_snappy")
-			require.NoError(t, err)
-			blockSSZ, err := snappy.Decode(nil /* dst */, blockFile)
-			require.NoError(t, err, "Failed to decompress")
-			block := &ethpb.BeaconBlockAltair{}
-			require.NoError(t, block.UnmarshalSSZ(blockSSZ), "Failed to unmarshal")
-
-			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
-			require.NoError(t, err)
-			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
-			require.NoError(t, err, "Failed to decompress")
-			preBeaconStateBase := &ethpb.BeaconStateAltair{}
-			require.NoError(t, preBeaconStateBase.UnmarshalSSZ(preBeaconStateSSZ), "Failed to unmarshal")
-			preBeaconState, err := state_native.InitializeFromProtoAltair(preBeaconStateBase)
-			require.NoError(t, err)
-
-			// If the post.ssz is not present, it means the test should fail on our end.
-			postSSZFilepath, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "post.ssz_snappy"))
-			postSSZExists := true
-			if err != nil && strings.Contains(err.Error(), "could not locate file") {
-				postSSZExists = false
-			} else {
-				require.NoError(t, err)
-			}
-
-			// Spectest blocks are not signed, so we'll call NoVerify to skip sig verification.
-			bodyRoot, err := block.Body.HashTreeRoot()
-			require.NoError(t, err)
-			beaconState, err := blocks.ProcessBlockHeaderNoVerify(context.Background(), preBeaconState, block.Slot, block.ProposerIndex, block.ParentRoot, bodyRoot[:])
-			if postSSZExists {
-				require.NoError(t, err)
-
-				postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
-				require.NoError(t, err)
-				postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
-				require.NoError(t, err, "Failed to decompress")
-
-				postBeaconState := &ethpb.BeaconStateAltair{}
-				require.NoError(t, postBeaconState.UnmarshalSSZ(postBeaconStateSSZ), "Failed to unmarshal")
-				pbState, err := state_native.ProtobufBeaconStateAltair(beaconState.ToProto())
-				require.NoError(t, err)
-				if !proto.Equal(pbState, postBeaconState) {
-					t.Log(cmp.Diff(postBeaconState, pbState, protocmp.Transform()))
-					t.Fatal("Post state does not match expected")
-				}
-			} else {
-				// Note: This doesn't test anything worthwhile. It essentially tests
-				// that *any* error has occurred, not any specific error.
-				if err == nil {
-					t.Fatal("Did not fail when expected")
-				}
-				t.Logf("Expected failure; failure reason = %v", err)
-				return
-			}
-		})
-	}
+	common.RunBlockHeaderTest(t, config, version.String(version.Altair), sszToBlock, sszToState)
 }

testing/spectest/shared/altair/operations/deposit.go

@@ -1,41 +1,27 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunDepositTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "altair", "operations/deposit/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "altair", "operations/deposit/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			depositFile, err := util.BazelFileBytes(folderPath, "deposit.ssz_snappy")
-			require.NoError(t, err)
-			depositSSZ, err := snappy.Decode(nil /* dst */, depositFile)
-			require.NoError(t, err, "Failed to decompress")
-			deposit := &ethpb.Deposit{}
-			require.NoError(t, deposit.UnmarshalSSZ(depositSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyAltair{Deposits: []*ethpb.Deposit{deposit}}
-			processDepositsFunc := func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return altair.ProcessDeposits(ctx, s, b.Block().Body().Deposits())
-			}
-			RunBlockOperationTest(t, folderPath, body, processDepositsFunc)
-		})
+func blockWithDeposit(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	d := &ethpb.Deposit{}
+	if err := d.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockAltair()
+	b.Block.Body = &ethpb.BeaconBlockBodyAltair{Deposits: []*ethpb.Deposit{d}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunDepositTest(t *testing.T, config string) {
+	common.RunDepositTest(t, config, version.String(version.Altair), blockWithDeposit, altair.ProcessDeposits, sszToState)
 }

testing/spectest/shared/altair/operations/helpers.go

@@ -1,88 +1,25 @@
 package operations
 
 import (
-	"context"
-	"os"
-	"path"
-	"strings"
-	"testing"
-
-	"github.com/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/golang/snappy"
-	"github.com/google/go-cmp/cmp"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/testing/protocmp"
 )
 
-type blockOperation func(context.Context, state.BeaconState, interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error)
-
-// RunBlockOperationTest takes in the prestate and the beacon block body, processes it through the
-// passed in block operation function and checks the post state with the expected post state.
-func RunBlockOperationTest(
-	t *testing.T,
-	folderPath string,
-	body *ethpb.BeaconBlockBodyAltair,
-	operationFn blockOperation,
-) {
-	preBeaconStateFile, err := util.BazelFileBytes(path.Join(folderPath, "pre.ssz_snappy"))
-	require.NoError(t, err)
-	preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
-	require.NoError(t, err, "Failed to decompress")
-	preStateBase := &ethpb.BeaconStateAltair{}
-	if err := preStateBase.UnmarshalSSZ(preBeaconStateSSZ); err != nil {
-		t.Fatalf("Failed to unmarshal: %v", err)
-	}
-	preState, err := state_native.InitializeFromProtoAltair(preStateBase)
-	require.NoError(t, err)
-
-	// If the post.ssz is not present, it means the test should fail on our end.
-	postSSZFilepath, err := bazel.Runfile(path.Join(folderPath, "post.ssz_snappy"))
-	postSSZExists := true
-	if err != nil && strings.Contains(err.Error(), "could not locate file") {
-		postSSZExists = false
-	} else if err != nil {
-		t.Fatal(err)
-	}
-
-	helpers.ClearCache()
-	b := util.NewBeaconBlockAltair()
-	b.Block.Body = body
-	wsb, err := blocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	beaconState, err := operationFn(context.Background(), preState, wsb)
-	if postSSZExists {
-		require.NoError(t, err)
-
-		postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
-		require.NoError(t, err)
-		postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
-		require.NoError(t, err, "Failed to decompress")
-
-		postBeaconState := &ethpb.BeaconStateAltair{}
-		if err := postBeaconState.UnmarshalSSZ(postBeaconStateSSZ); err != nil {
-			t.Fatalf("Failed to unmarshal: %v", err)
-		}
-		pbState, err := state_native.ProtobufBeaconStateAltair(beaconState.ToProtoUnsafe())
-		require.NoError(t, err)
-		if !proto.Equal(pbState, postBeaconState) {
-			t.Log(cmp.Diff(postBeaconState, pbState, protocmp.Transform()))
-			t.Fatal("Post state does not match expected")
-		}
-	} else {
-		// Note: This doesn't test anything worthwhile. It essentially tests
-		// that *any* error has occurred, not any specific error.
-		if err == nil {
-			t.Fatal("Did not fail when expected")
-		}
-		t.Logf("Expected failure; failure reason = %v", err)
-		return
+func sszToState(b []byte) (state.BeaconState, error) {
+	base := &ethpb.BeaconStateAltair{}
+	if err := base.UnmarshalSSZ(b); err != nil {
+		return nil, err
 	}
+	return state_native.InitializeFromProtoAltair(base)
+}
+
+func sszToBlock(b []byte) (interfaces.SignedBeaconBlock, error) {
+	base := &ethpb.BeaconBlockAltair{}
+	if err := base.UnmarshalSSZ(b); err != nil {
+		return nil, err
+	}
+	return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: base})
 }

testing/spectest/shared/altair/operations/proposer_slashing.go

@@ -1,41 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunProposerSlashingTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "altair", "operations/proposer_slashing/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "altair", "operations/proposer_slashing/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			proposerSlashingFile, err := util.BazelFileBytes(folderPath, "proposer_slashing.ssz_snappy")
-			require.NoError(t, err)
-			proposerSlashingSSZ, err := snappy.Decode(nil /* dst */, proposerSlashingFile)
-			require.NoError(t, err, "Failed to decompress")
-			proposerSlashing := &ethpb.ProposerSlashing{}
-			require.NoError(t, proposerSlashing.UnmarshalSSZ(proposerSlashingSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyAltair{ProposerSlashings: []*ethpb.ProposerSlashing{proposerSlashing}}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return blocks.ProcessProposerSlashings(ctx, s, b.Block().Body().ProposerSlashings(), validators.SlashValidator)
-			})
-		})
+func blockWithProposerSlashing(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	ps := &ethpb.ProposerSlashing{}
+	if err := ps.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockAltair()
+	b.Block.Body = &ethpb.BeaconBlockBodyAltair{ProposerSlashings: []*ethpb.ProposerSlashing{ps}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunProposerSlashingTest(t *testing.T, config string) {
+	common.RunProposerSlashingTest(t, config, version.String(version.Altair), blockWithProposerSlashing, sszToState)
 }

testing/spectest/shared/altair/operations/sync_committee.go

@@ -1,44 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunSyncCommitteeTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "altair", "operations/sync_aggregate/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "altair", "operations/sync_aggregate/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			syncCommitteeFile, err := util.BazelFileBytes(folderPath, "sync_aggregate.ssz_snappy")
-			require.NoError(t, err)
-			syncCommitteeSSZ, err := snappy.Decode(nil /* dst */, syncCommitteeFile)
-			require.NoError(t, err, "Failed to decompress")
-			sc := &ethpb.SyncAggregate{}
-			require.NoError(t, sc.UnmarshalSSZ(syncCommitteeSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyAltair{SyncAggregate: sc}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				st, _, err := altair.ProcessSyncAggregate(context.Background(), s, body.SyncAggregate)
-				if err != nil {
-					return nil, err
-				}
-				return st, nil
-			})
-		})
+func blockWithSyncAggregate(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	sa := &ethpb.SyncAggregate{}
+	if err := sa.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockAltair()
+	b.Block.Body = &ethpb.BeaconBlockBodyAltair{SyncAggregate: sa}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunSyncCommitteeTest(t *testing.T, config string) {
+	common.RunSyncCommitteeTest(t, config, version.String(version.Altair), blockWithSyncAggregate, sszToState)
 }

testing/spectest/shared/altair/operations/voluntary_exit.go

@@ -1,40 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunVoluntaryExitTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "altair", "operations/voluntary_exit/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "altair", "operations/voluntary_exit/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			exitFile, err := util.BazelFileBytes(folderPath, "voluntary_exit.ssz_snappy")
-			require.NoError(t, err)
-			exitSSZ, err := snappy.Decode(nil /* dst */, exitFile)
-			require.NoError(t, err, "Failed to decompress")
-			voluntaryExit := &ethpb.SignedVoluntaryExit{}
-			require.NoError(t, voluntaryExit.UnmarshalSSZ(exitSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyAltair{VoluntaryExits: []*ethpb.SignedVoluntaryExit{voluntaryExit}}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return blocks.ProcessVoluntaryExits(ctx, s, b.Block().Body().VoluntaryExits())
-			})
-		})
+func blockWithVoluntaryExit(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	e := &ethpb.SignedVoluntaryExit{}
+	if err := e.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockAltair()
+	b.Block.Body = &ethpb.BeaconBlockBodyAltair{VoluntaryExits: []*ethpb.SignedVoluntaryExit{e}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunVoluntaryExitTest(t *testing.T, config string) {
+	common.RunVoluntaryExitTest(t, config, version.String(version.Altair), blockWithVoluntaryExit, sszToState)
 }

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

@@ -18,21 +18,13 @@ go_library(
     visibility = ["//testing/spectest:__subpackages__"],
     deps = [
         "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/blocks:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/validators: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",
-        "//testing/require:go_default_library",
-        "//testing/spectest/utils:go_default_library",
+        "//runtime/version:go_default_library",
+        "//testing/spectest/shared/common/operations:go_default_library",
         "//testing/util:go_default_library",
-        "@com_github_golang_snappy//:go_default_library",
-        "@com_github_google_go_cmp//cmp:go_default_library",
-        "@io_bazel_rules_go//go/tools/bazel:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-        "@org_golang_google_protobuf//testing/protocmp:go_default_library",
     ],
 )

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

@@ -1,59 +1,27 @@
 package operations
 
 import (
-	"context"
-	"errors"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	b "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunAttestationTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "bellatrix", "operations/attestation/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "bellatrix", "operations/attestation/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			attestationFile, err := util.BazelFileBytes(folderPath, "attestation.ssz_snappy")
-			require.NoError(t, err)
-			attestationSSZ, err := snappy.Decode(nil /* dst */, attestationFile)
-			require.NoError(t, err, "Failed to decompress")
-			att := &ethpb.Attestation{}
-			require.NoError(t, att.UnmarshalSSZ(attestationSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyBellatrix{Attestations: []*ethpb.Attestation{att}}
-			processAtt := func(ctx context.Context, st state.BeaconState, blk interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				st, err = altair.ProcessAttestationsNoVerifySignature(ctx, st, blk.Block())
-				if err != nil {
-					return nil, err
-				}
-				aSet, err := b.AttestationSignatureBatch(ctx, st, blk.Block().Body().Attestations())
-				if err != nil {
-					return nil, err
-				}
-				verified, err := aSet.Verify()
-				if err != nil {
-					return nil, err
-				}
-				if !verified {
-					return nil, errors.New("could not batch verify attestation signature")
-				}
-				return st, nil
-			}
-
-			RunBlockOperationTest(t, folderPath, body, processAtt)
-		})
+func blockWithAttestation(attestationSSZ []byte) (interfaces.SignedBeaconBlock, error) {
+	att := &ethpb.Attestation{}
+	if err := att.UnmarshalSSZ(attestationSSZ); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockBellatrix()
+	b.Block.Body = &ethpb.BeaconBlockBodyBellatrix{Attestations: []*ethpb.Attestation{att}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunAttestationTest(t *testing.T, config string) {
+	common.RunAttestationTest(t, config, version.String(version.Bellatrix), blockWithAttestation, altair.ProcessAttestationsNoVerifySignature, sszToState)
 }

testing/spectest/shared/bellatrix/operations/attester_slashing.go

@@ -1,41 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunAttesterSlashingTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "bellatrix", "operations/attester_slashing/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "bellatrix", "operations/attester_slashing/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			attSlashingFile, err := util.BazelFileBytes(folderPath, "attester_slashing.ssz_snappy")
-			require.NoError(t, err)
-			attSlashingSSZ, err := snappy.Decode(nil /* dst */, attSlashingFile)
-			require.NoError(t, err, "Failed to decompress")
-			attSlashing := &ethpb.AttesterSlashing{}
-			require.NoError(t, attSlashing.UnmarshalSSZ(attSlashingSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyBellatrix{AttesterSlashings: []*ethpb.AttesterSlashing{attSlashing}}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return blocks.ProcessAttesterSlashings(ctx, s, b.Block().Body().AttesterSlashings(), validators.SlashValidator)
-			})
-		})
+func blockWithAttesterSlashing(asSSZ []byte) (interfaces.SignedBeaconBlock, error) {
+	as := &ethpb.AttesterSlashing{}
+	if err := as.UnmarshalSSZ(asSSZ); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockBellatrix()
+	b.Block.Body = &ethpb.BeaconBlockBodyBellatrix{AttesterSlashings: []*ethpb.AttesterSlashing{as}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunAttesterSlashingTest(t *testing.T, config string) {
+	common.RunAttesterSlashingTest(t, config, version.String(version.Bellatrix), blockWithAttesterSlashing, sszToState)
 }

testing/spectest/shared/bellatrix/operations/block_header.go

@@ -1,90 +1,12 @@
 package operations
 
 import (
-	"context"
-	"os"
-	"path"
-	"strings"
 	"testing"
 
-	"github.com/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/golang/snappy"
-	"github.com/google/go-cmp/cmp"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/testing/protocmp"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 )
 
 func RunBlockHeaderTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "bellatrix", "operations/block_header/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "bellatrix", "operations/block_header/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			helpers.ClearCache()
-
-			blockFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "block.ssz_snappy")
-			require.NoError(t, err)
-			blockSSZ, err := snappy.Decode(nil /* dst */, blockFile)
-			require.NoError(t, err, "Failed to decompress")
-			block := &ethpb.BeaconBlockBellatrix{}
-			require.NoError(t, block.UnmarshalSSZ(blockSSZ), "Failed to unmarshal")
-
-			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
-			require.NoError(t, err)
-			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
-			require.NoError(t, err, "Failed to decompress")
-			preBeaconStateBase := &ethpb.BeaconStateBellatrix{}
-			require.NoError(t, preBeaconStateBase.UnmarshalSSZ(preBeaconStateSSZ), "Failed to unmarshal")
-			preBeaconState, err := state_native.InitializeFromProtoBellatrix(preBeaconStateBase)
-			require.NoError(t, err)
-
-			// If the post.ssz is not present, it means the test should fail on our end.
-			postSSZFilepath, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "post.ssz_snappy"))
-			postSSZExists := true
-			if err != nil && strings.Contains(err.Error(), "could not locate file") {
-				postSSZExists = false
-			} else {
-				require.NoError(t, err)
-			}
-
-			// Spectest blocks are not signed, so we'll call NoVerify to skip sig verification.
-			bodyRoot, err := block.Body.HashTreeRoot()
-			require.NoError(t, err)
-			beaconState, err := blocks.ProcessBlockHeaderNoVerify(context.Background(), preBeaconState, block.Slot, block.ProposerIndex, block.ParentRoot, bodyRoot[:])
-			if postSSZExists {
-				require.NoError(t, err)
-
-				postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
-				require.NoError(t, err)
-				postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
-				require.NoError(t, err, "Failed to decompress")
-
-				postBeaconState := &ethpb.BeaconStateBellatrix{}
-				require.NoError(t, postBeaconState.UnmarshalSSZ(postBeaconStateSSZ), "Failed to unmarshal")
-				pbState, err := state_native.ProtobufBeaconStateBellatrix(beaconState.ToProto())
-				require.NoError(t, err)
-				if !proto.Equal(pbState, postBeaconState) {
-					t.Log(cmp.Diff(postBeaconState, pbState, protocmp.Transform()))
-					t.Fatal("Post state does not match expected")
-				}
-			} else {
-				// Note: This doesn't test anything worthwhile. It essentially tests
-				// that *any* error has occurred, not any specific error.
-				if err == nil {
-					t.Fatal("Did not fail when expected")
-				}
-				t.Logf("Expected failure; failure reason = %v", err)
-				return
-			}
-		})
-	}
+	common.RunBlockHeaderTest(t, config, version.String(version.Bellatrix), sszToBlock, sszToState)
 }

testing/spectest/shared/bellatrix/operations/deposit.go

@@ -1,41 +1,27 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunDepositTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "bellatrix", "operations/deposit/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "bellatrix", "operations/deposit/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			depositFile, err := util.BazelFileBytes(folderPath, "deposit.ssz_snappy")
-			require.NoError(t, err)
-			depositSSZ, err := snappy.Decode(nil /* dst */, depositFile)
-			require.NoError(t, err, "Failed to decompress")
-			deposit := &ethpb.Deposit{}
-			require.NoError(t, deposit.UnmarshalSSZ(depositSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyBellatrix{Deposits: []*ethpb.Deposit{deposit}}
-			processDepositsFunc := func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return altair.ProcessDeposits(ctx, s, b.Block().Body().Deposits())
-			}
-			RunBlockOperationTest(t, folderPath, body, processDepositsFunc)
-		})
+func blockWithDeposit(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	d := &ethpb.Deposit{}
+	if err := d.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockBellatrix()
+	b.Block.Body = &ethpb.BeaconBlockBodyBellatrix{Deposits: []*ethpb.Deposit{d}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunDepositTest(t *testing.T, config string) {
+	common.RunDepositTest(t, config, version.String(version.Bellatrix), blockWithDeposit, altair.ProcessDeposits, sszToState)
 }

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

@@ -1,98 +1,12 @@
 package operations
 
 import (
-	"os"
-	"path"
-	"strings"
 	"testing"
 
-	"github.com/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/golang/snappy"
-	"github.com/google/go-cmp/cmp"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
-	blocks2 "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/testing/protocmp"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 )
 
 func RunExecutionPayloadTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "bellatrix", "operations/execution_payload/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "bellatrix", "operations/execution_payload/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			helpers.ClearCache()
-
-			blockBodyFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "body.ssz_snappy")
-			require.NoError(t, err)
-			blockSSZ, err := snappy.Decode(nil /* dst */, blockBodyFile)
-			require.NoError(t, err, "Failed to decompress")
-			block := &ethpb.BeaconBlockBodyBellatrix{}
-			require.NoError(t, block.UnmarshalSSZ(blockSSZ), "Failed to unmarshal")
-
-			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
-			require.NoError(t, err)
-			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
-			require.NoError(t, err, "Failed to decompress")
-			preBeaconStateBase := &ethpb.BeaconStateBellatrix{}
-			require.NoError(t, preBeaconStateBase.UnmarshalSSZ(preBeaconStateSSZ), "Failed to unmarshal")
-			preBeaconState, err := state_native.InitializeFromProtoBellatrix(preBeaconStateBase)
-			require.NoError(t, err)
-
-			postSSZFilepath, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "post.ssz_snappy"))
-			postSSZExists := true
-			if err != nil && strings.Contains(err.Error(), "could not locate file") {
-				postSSZExists = false
-			} else {
-				require.NoError(t, err)
-			}
-
-			payload, err := blocks2.WrappedExecutionPayload(block.ExecutionPayload)
-			require.NoError(t, err)
-
-			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "execution.yaml")
-			require.NoError(t, err)
-			config := &ExecutionConfig{}
-			require.NoError(t, utils.UnmarshalYaml(file, config), "Failed to Unmarshal")
-
-			gotState, err := blocks.ProcessPayload(preBeaconState, payload)
-			if postSSZExists {
-				require.NoError(t, err)
-
-				postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
-				require.NoError(t, err)
-				postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
-				require.NoError(t, err, "Failed to decompress")
-
-				postBeaconState := &ethpb.BeaconStateBellatrix{}
-				require.NoError(t, postBeaconState.UnmarshalSSZ(postBeaconStateSSZ), "Failed to unmarshal")
-				pbState, err := state_native.ProtobufBeaconStateBellatrix(gotState.ToProto())
-				require.NoError(t, err)
-				if !proto.Equal(pbState, postBeaconState) {
-					t.Log(cmp.Diff(postBeaconState, pbState, protocmp.Transform()))
-					t.Fatal("Post state does not match expected")
-				}
-			} else if config.Valid {
-				// Note: This doesn't test anything worthwhile. It essentially tests
-				// that *any* error has occurred, not any specific error.
-				if err == nil {
-					t.Fatal("Did not fail when expected")
-				}
-				t.Logf("Expected failure; failure reason = %v", err)
-				return
-			}
-		})
-	}
-}
-
-type ExecutionConfig struct {
-	Valid bool `json:"execution_valid"`
+	common.RunExecutionPayloadTest(t, config, version.String(version.Bellatrix), sszToBlockBody, sszToState)
 }

testing/spectest/shared/bellatrix/operations/helpers.go

@@ -1,88 +1,33 @@
 package operations
 
 import (
-	"context"
-	"os"
-	"path"
-	"strings"
-	"testing"
-
-	"github.com/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/golang/snappy"
-	"github.com/google/go-cmp/cmp"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/testing/protocmp"
 )
 
-type blockOperation func(context.Context, state.BeaconState, interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error)
-
-// RunBlockOperationTest takes in the prestate and the beacon block body, processes it through the
-// passed in block operation function and checks the post state with the expected post state.
-func RunBlockOperationTest(
-	t *testing.T,
-	folderPath string,
-	body *ethpb.BeaconBlockBodyBellatrix,
-	operationFn blockOperation,
-) {
-	preBeaconStateFile, err := util.BazelFileBytes(path.Join(folderPath, "pre.ssz_snappy"))
-	require.NoError(t, err)
-	preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
-	require.NoError(t, err, "Failed to decompress")
-	preStateBase := &ethpb.BeaconStateBellatrix{}
-	if err := preStateBase.UnmarshalSSZ(preBeaconStateSSZ); err != nil {
-		t.Fatalf("Failed to unmarshal: %v", err)
-	}
-	preState, err := state_native.InitializeFromProtoBellatrix(preStateBase)
-	require.NoError(t, err)
-
-	// If the post.ssz is not present, it means the test should fail on our end.
-	postSSZFilepath, err := bazel.Runfile(path.Join(folderPath, "post.ssz_snappy"))
-	postSSZExists := true
-	if err != nil && strings.Contains(err.Error(), "could not locate file") {
-		postSSZExists = false
-	} else if err != nil {
-		t.Fatal(err)
-	}
-
-	helpers.ClearCache()
-	b := util.NewBeaconBlockBellatrix()
-	b.Block.Body = body
-	wsb, err := blocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	beaconState, err := operationFn(context.Background(), preState, wsb)
-	if postSSZExists {
-		require.NoError(t, err)
-
-		postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
-		require.NoError(t, err)
-		postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
-		require.NoError(t, err, "Failed to decompress")
-
-		postBeaconState := &ethpb.BeaconStateBellatrix{}
-		if err := postBeaconState.UnmarshalSSZ(postBeaconStateSSZ); err != nil {
-			t.Fatalf("Failed to unmarshal: %v", err)
-		}
-		pbState, err := state_native.ProtobufBeaconStateBellatrix(beaconState.ToProtoUnsafe())
-		require.NoError(t, err)
-		if !proto.Equal(pbState, postBeaconState) {
-			t.Log(cmp.Diff(postBeaconState, pbState, protocmp.Transform()))
-			t.Fatal("Post state does not match expected")
-		}
-	} else {
-		// Note: This doesn't test anything worthwhile. It essentially tests
-		// that *any* error has occurred, not any specific error.
-		if err == nil {
-			t.Fatal("Did not fail when expected")
-		}
-		t.Logf("Expected failure; failure reason = %v", err)
-		return
+func sszToState(b []byte) (state.BeaconState, error) {
+	base := &ethpb.BeaconStateBellatrix{}
+	if err := base.UnmarshalSSZ(b); err != nil {
+		return nil, err
 	}
+	return state_native.InitializeFromProtoBellatrix(base)
+}
+
+func sszToBlock(b []byte) (interfaces.SignedBeaconBlock, error) {
+	base := &ethpb.BeaconBlockBellatrix{}
+	if err := base.UnmarshalSSZ(b); err != nil {
+		return nil, err
+	}
+	return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: base})
+}
+
+func sszToBlockBody(b []byte) (interfaces.ReadOnlyBeaconBlockBody, error) {
+	base := &ethpb.BeaconBlockBodyBellatrix{}
+	if err := base.UnmarshalSSZ(b); err != nil {
+		return nil, err
+	}
+	return blocks.NewBeaconBlockBody(base)
 }

testing/spectest/shared/bellatrix/operations/proposer_slashing.go

@@ -1,41 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunProposerSlashingTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "bellatrix", "operations/proposer_slashing/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "bellatrix", "operations/proposer_slashing/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			proposerSlashingFile, err := util.BazelFileBytes(folderPath, "proposer_slashing.ssz_snappy")
-			require.NoError(t, err)
-			proposerSlashingSSZ, err := snappy.Decode(nil /* dst */, proposerSlashingFile)
-			require.NoError(t, err, "Failed to decompress")
-			proposerSlashing := &ethpb.ProposerSlashing{}
-			require.NoError(t, proposerSlashing.UnmarshalSSZ(proposerSlashingSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyBellatrix{ProposerSlashings: []*ethpb.ProposerSlashing{proposerSlashing}}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return blocks.ProcessProposerSlashings(ctx, s, b.Block().Body().ProposerSlashings(), validators.SlashValidator)
-			})
-		})
+func blockWithProposerSlashing(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	ps := &ethpb.ProposerSlashing{}
+	if err := ps.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockBellatrix()
+	b.Block.Body = &ethpb.BeaconBlockBodyBellatrix{ProposerSlashings: []*ethpb.ProposerSlashing{ps}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunProposerSlashingTest(t *testing.T, config string) {
+	common.RunProposerSlashingTest(t, config, version.String(version.Bellatrix), blockWithProposerSlashing, sszToState)
 }

testing/spectest/shared/bellatrix/operations/sync_committee.go

@@ -1,44 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunSyncCommitteeTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "bellatrix", "operations/sync_aggregate/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "bellatrix", "operations/sync_aggregate/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			syncCommitteeFile, err := util.BazelFileBytes(folderPath, "sync_aggregate.ssz_snappy")
-			require.NoError(t, err)
-			syncCommitteeSSZ, err := snappy.Decode(nil /* dst */, syncCommitteeFile)
-			require.NoError(t, err, "Failed to decompress")
-			sc := &ethpb.SyncAggregate{}
-			require.NoError(t, sc.UnmarshalSSZ(syncCommitteeSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyBellatrix{SyncAggregate: sc}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				st, _, err := altair.ProcessSyncAggregate(context.Background(), s, body.SyncAggregate)
-				if err != nil {
-					return nil, err
-				}
-				return st, nil
-			})
-		})
+func blockWithSyncAggregate(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	sa := &ethpb.SyncAggregate{}
+	if err := sa.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockBellatrix()
+	b.Block.Body = &ethpb.BeaconBlockBodyBellatrix{SyncAggregate: sa}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunSyncCommitteeTest(t *testing.T, config string) {
+	common.RunSyncCommitteeTest(t, config, version.String(version.Bellatrix), blockWithSyncAggregate, sszToState)
 }

testing/spectest/shared/bellatrix/operations/voluntary_exit.go

@@ -1,40 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunVoluntaryExitTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "bellatrix", "operations/voluntary_exit/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "bellatrix", "operations/voluntary_exit/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			exitFile, err := util.BazelFileBytes(folderPath, "voluntary_exit.ssz_snappy")
-			require.NoError(t, err)
-			exitSSZ, err := snappy.Decode(nil /* dst */, exitFile)
-			require.NoError(t, err, "Failed to decompress")
-			voluntaryExit := &ethpb.SignedVoluntaryExit{}
-			require.NoError(t, voluntaryExit.UnmarshalSSZ(exitSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyBellatrix{VoluntaryExits: []*ethpb.SignedVoluntaryExit{voluntaryExit}}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return blocks.ProcessVoluntaryExits(ctx, s, b.Block().Body().VoluntaryExits())
-			})
-		})
+func blockWithVoluntaryExit(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	e := &ethpb.SignedVoluntaryExit{}
+	if err := e.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockBellatrix()
+	b.Block.Body = &ethpb.BeaconBlockBodyBellatrix{VoluntaryExits: []*ethpb.SignedVoluntaryExit{e}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunVoluntaryExitTest(t *testing.T, config string) {
+	common.RunVoluntaryExitTest(t, config, version.String(version.Bellatrix), blockWithVoluntaryExit, sszToState)
 }

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

@@ -20,23 +20,14 @@ go_library(
     visibility = ["//testing/spectest:__subpackages__"],
     deps = [
         "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/blocks:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/validators: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/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/spectest/utils:go_default_library",
+        "//runtime/version:go_default_library",
+        "//testing/spectest/shared/common/operations:go_default_library",
         "//testing/util:go_default_library",
-        "@com_github_golang_snappy//:go_default_library",
-        "@com_github_google_go_cmp//cmp:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@io_bazel_rules_go//go/tools/bazel:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-        "@org_golang_google_protobuf//testing/protocmp:go_default_library",
     ],
 )

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

@@ -1,59 +1,27 @@
 package operations
 
 import (
-	"context"
-	"errors"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	b "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunAttestationTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "capella", "operations/attestation/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "capella", "operations/attestation/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			attestationFile, err := util.BazelFileBytes(folderPath, "attestation.ssz_snappy")
-			require.NoError(t, err)
-			attestationSSZ, err := snappy.Decode(nil /* dst */, attestationFile)
-			require.NoError(t, err, "Failed to decompress")
-			att := &ethpb.Attestation{}
-			require.NoError(t, att.UnmarshalSSZ(attestationSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyCapella{Attestations: []*ethpb.Attestation{att}}
-			processAtt := func(ctx context.Context, st state.BeaconState, blk interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				st, err = altair.ProcessAttestationsNoVerifySignature(ctx, st, blk.Block())
-				if err != nil {
-					return nil, err
-				}
-				aSet, err := b.AttestationSignatureBatch(ctx, st, blk.Block().Body().Attestations())
-				if err != nil {
-					return nil, err
-				}
-				verified, err := aSet.Verify()
-				if err != nil {
-					return nil, err
-				}
-				if !verified {
-					return nil, errors.New("could not batch verify attestation signature")
-				}
-				return st, nil
-			}
-
-			RunBlockOperationTest(t, folderPath, body, processAtt)
-		})
+func blockWithAttestation(attestationSSZ []byte) (interfaces.SignedBeaconBlock, error) {
+	att := &ethpb.Attestation{}
+	if err := att.UnmarshalSSZ(attestationSSZ); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockCapella()
+	b.Block.Body = &ethpb.BeaconBlockBodyCapella{Attestations: []*ethpb.Attestation{att}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunAttestationTest(t *testing.T, config string) {
+	common.RunAttestationTest(t, config, version.String(version.Capella), blockWithAttestation, altair.ProcessAttestationsNoVerifySignature, sszToState)
 }

testing/spectest/shared/capella/operations/attester_slashing.go

@@ -1,41 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunAttesterSlashingTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "capella", "operations/attester_slashing/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "capella", "operations/attester_slashing/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			attSlashingFile, err := util.BazelFileBytes(folderPath, "attester_slashing.ssz_snappy")
-			require.NoError(t, err)
-			attSlashingSSZ, err := snappy.Decode(nil /* dst */, attSlashingFile)
-			require.NoError(t, err, "Failed to decompress")
-			attSlashing := &ethpb.AttesterSlashing{}
-			require.NoError(t, attSlashing.UnmarshalSSZ(attSlashingSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyCapella{AttesterSlashings: []*ethpb.AttesterSlashing{attSlashing}}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return blocks.ProcessAttesterSlashings(ctx, s, b.Block().Body().AttesterSlashings(), validators.SlashValidator)
-			})
-		})
+func blockWithAttesterSlashing(asSSZ []byte) (interfaces.SignedBeaconBlock, error) {
+	as := &ethpb.AttesterSlashing{}
+	if err := as.UnmarshalSSZ(asSSZ); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockCapella()
+	b.Block.Body = &ethpb.BeaconBlockBodyCapella{AttesterSlashings: []*ethpb.AttesterSlashing{as}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunAttesterSlashingTest(t *testing.T, config string) {
+	common.RunAttesterSlashingTest(t, config, version.String(version.Capella), blockWithAttesterSlashing, sszToState)
 }

testing/spectest/shared/capella/operations/block_header.go

@@ -1,90 +1,12 @@
 package operations
 
 import (
-	"context"
-	"os"
-	"path"
-	"strings"
 	"testing"
 
-	"github.com/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/golang/snappy"
-	"github.com/google/go-cmp/cmp"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/testing/protocmp"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 )
 
 func RunBlockHeaderTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "capella", "operations/block_header/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "capella", "operations/block_header/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			helpers.ClearCache()
-
-			blockFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "block.ssz_snappy")
-			require.NoError(t, err)
-			blockSSZ, err := snappy.Decode(nil /* dst */, blockFile)
-			require.NoError(t, err, "Failed to decompress")
-			block := &ethpb.BeaconBlockCapella{}
-			require.NoError(t, block.UnmarshalSSZ(blockSSZ), "Failed to unmarshal")
-
-			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
-			require.NoError(t, err)
-			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
-			require.NoError(t, err, "Failed to decompress")
-			preBeaconStateBase := &ethpb.BeaconStateCapella{}
-			require.NoError(t, preBeaconStateBase.UnmarshalSSZ(preBeaconStateSSZ), "Failed to unmarshal")
-			preBeaconState, err := state_native.InitializeFromProtoCapella(preBeaconStateBase)
-			require.NoError(t, err)
-
-			// If the post.ssz is not present, it means the test should fail on our end.
-			postSSZFilepath, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "post.ssz_snappy"))
-			postSSZExists := true
-			if err != nil && strings.Contains(err.Error(), "could not locate file") {
-				postSSZExists = false
-			} else {
-				require.NoError(t, err)
-			}
-
-			// Spectest blocks are not signed, so we'll call NoVerify to skip sig verification.
-			bodyRoot, err := block.Body.HashTreeRoot()
-			require.NoError(t, err)
-			beaconState, err := blocks.ProcessBlockHeaderNoVerify(context.Background(), preBeaconState, block.Slot, block.ProposerIndex, block.ParentRoot, bodyRoot[:])
-			if postSSZExists {
-				require.NoError(t, err)
-
-				postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
-				require.NoError(t, err)
-				postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
-				require.NoError(t, err, "Failed to decompress")
-
-				postBeaconState := &ethpb.BeaconStateCapella{}
-				require.NoError(t, postBeaconState.UnmarshalSSZ(postBeaconStateSSZ), "Failed to unmarshal")
-				pbState, err := state_native.ProtobufBeaconStateCapella(beaconState.ToProto())
-				require.NoError(t, err)
-				if !proto.Equal(pbState, postBeaconState) {
-					t.Log(cmp.Diff(postBeaconState, pbState, protocmp.Transform()))
-					t.Fatal("Post state does not match expected")
-				}
-			} else {
-				// Note: This doesn't test anything worthwhile. It essentially tests
-				// that *any* error has occurred, not any specific error.
-				if err == nil {
-					t.Fatal("Did not fail when expected")
-				}
-				t.Logf("Expected failure; failure reason = %v", err)
-				return
-			}
-		})
-	}
+	common.RunBlockHeaderTest(t, config, version.String(version.Capella), sszToBlock, sszToState)
 }

testing/spectest/shared/capella/operations/bls_to_execution_changes.go

@@ -1,62 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunBLSToExecutionChangeTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "capella", "operations/bls_to_execution_change/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "capella", "operations/bls_to_execution_change/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			changeFile, err := util.BazelFileBytes(folderPath, "address_change.ssz_snappy")
-			require.NoError(t, err)
-			changeSSZ, err := snappy.Decode(nil /* dst */, changeFile)
-			require.NoError(t, err, "Failed to decompress")
-			change := &ethpb.SignedBLSToExecutionChange{}
-			require.NoError(t, change.UnmarshalSSZ(changeSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyCapella{
-				BlsToExecutionChanges: []*ethpb.SignedBLSToExecutionChange{change},
-			}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				st, err := blocks.ProcessBLSToExecutionChanges(s, b.Block())
-				if err != nil {
-					return nil, err
-				}
-				changes, err := b.Block().Body().BLSToExecutionChanges()
-				if err != nil {
-					return nil, err
-				}
-				cSet, err := blocks.BLSChangesSignatureBatch(st, changes)
-				if err != nil {
-					return nil, err
-				}
-				ok, err := cSet.Verify()
-				if err != nil {
-					return nil, err
-				}
-				if !ok {
-					return nil, errors.New("signature did not verify")
-				}
-				return st, nil
-			})
-		})
+func blockWithBlsChange(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	c := &ethpb.SignedBLSToExecutionChange{}
+	if err := c.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockCapella()
+	b.Block.Body = &ethpb.BeaconBlockBodyCapella{BlsToExecutionChanges: []*ethpb.SignedBLSToExecutionChange{c}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunBLSToExecutionChangeTest(t *testing.T, config string) {
+	common.RunBLSToExecutionChangeTest(t, config, version.String(version.Capella), blockWithBlsChange, sszToState)
 }

testing/spectest/shared/capella/operations/deposit.go

@@ -1,41 +1,27 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunDepositTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "capella", "operations/deposit/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "capella", "operations/deposit/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			depositFile, err := util.BazelFileBytes(folderPath, "deposit.ssz_snappy")
-			require.NoError(t, err)
-			depositSSZ, err := snappy.Decode(nil /* dst */, depositFile)
-			require.NoError(t, err, "Failed to decompress")
-			deposit := &ethpb.Deposit{}
-			require.NoError(t, deposit.UnmarshalSSZ(depositSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyCapella{Deposits: []*ethpb.Deposit{deposit}}
-			processDepositsFunc := func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return altair.ProcessDeposits(ctx, s, b.Block().Body().Deposits())
-			}
-			RunBlockOperationTest(t, folderPath, body, processDepositsFunc)
-		})
+func blockWithDeposit(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	d := &ethpb.Deposit{}
+	if err := d.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockCapella()
+	b.Block.Body = &ethpb.BeaconBlockBodyCapella{Deposits: []*ethpb.Deposit{d}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunDepositTest(t *testing.T, config string) {
+	common.RunDepositTest(t, config, version.String(version.Capella), blockWithDeposit, altair.ProcessDeposits, sszToState)
 }

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

@@ -1,99 +1,12 @@
 package operations
 
 import (
-	"os"
-	"path"
-	"strings"
 	"testing"
 
-	"github.com/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
-	blocks2 "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"google.golang.org/protobuf/proto"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 )
 
 func RunExecutionPayloadTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "capella", "operations/execution_payload/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "capella", "operations/execution_payload/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			helpers.ClearCache()
-
-			blockBodyFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "body.ssz_snappy")
-			require.NoError(t, err)
-			blockSSZ, err := snappy.Decode(nil /* dst */, blockBodyFile)
-			require.NoError(t, err, "Failed to decompress")
-			block := &ethpb.BeaconBlockBodyCapella{}
-			require.NoError(t, block.UnmarshalSSZ(blockSSZ), "Failed to unmarshal")
-
-			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
-			require.NoError(t, err)
-			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
-			require.NoError(t, err, "Failed to decompress")
-			preBeaconStateBase := &ethpb.BeaconStateCapella{}
-			require.NoError(t, preBeaconStateBase.UnmarshalSSZ(preBeaconStateSSZ), "Failed to unmarshal")
-			preBeaconState, err := state_native.InitializeFromProtoCapella(preBeaconStateBase)
-			require.NoError(t, err)
-
-			postSSZFilepath, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "post.ssz_snappy"))
-			postSSZExists := true
-			if err != nil && strings.Contains(err.Error(), "could not locate file") {
-				postSSZExists = false
-			} else {
-				require.NoError(t, err)
-			}
-
-			payload, err := blocks2.WrappedExecutionPayloadCapella(block.ExecutionPayload)
-			require.NoError(t, err)
-
-			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "execution.yaml")
-			require.NoError(t, err)
-			config := &ExecutionConfig{}
-			require.NoError(t, utils.UnmarshalYaml(file, config), "Failed to Unmarshal")
-
-			if postSSZExists {
-				require.NoError(t, blocks.ValidatePayloadWhenMergeCompletes(preBeaconState, payload))
-				require.NoError(t, blocks.ValidatePayload(preBeaconState, payload))
-				require.NoError(t, preBeaconState.SetLatestExecutionPayloadHeader(payload))
-				postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
-				require.NoError(t, err)
-				postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
-				require.NoError(t, err, "Failed to decompress")
-
-				postBeaconState := &ethpb.BeaconStateCapella{}
-				require.NoError(t, postBeaconState.UnmarshalSSZ(postBeaconStateSSZ), "Failed to unmarshal")
-				pbState, err := state_native.ProtobufBeaconStateCapella(preBeaconState.ToProto())
-				require.NoError(t, err)
-				t.Log(pbState)
-				t.Log(postBeaconState)
-				if !proto.Equal(pbState, postBeaconState) {
-					t.Fatal("Post state does not match expected")
-				}
-			} else if config.Valid {
-				err1 := blocks.ValidatePayloadWhenMergeCompletes(preBeaconState, payload)
-				err2 := blocks.ValidatePayload(preBeaconState, payload)
-				// Note: This doesn't test anything worthwhile. It essentially tests
-				// that *any* error has occurred, not any specific error.
-				if err1 == nil && err2 == nil {
-					t.Fatal("Did not fail when expected")
-				}
-				t.Logf("Expected failure; failure reason = %v", err)
-				return
-			}
-		})
-	}
-}
-
-type ExecutionConfig struct {
-	Valid bool `json:"execution_valid"`
+	common.RunExecutionPayloadTest(t, config, version.String(version.Capella), sszToBlockBody, sszToState)
 }

testing/spectest/shared/capella/operations/helpers.go

@@ -1,88 +1,33 @@
 package operations
 
 import (
-	"context"
-	"os"
-	"path"
-	"strings"
-	"testing"
-
-	"github.com/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/golang/snappy"
-	"github.com/google/go-cmp/cmp"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/testing/protocmp"
 )
 
-type blockOperation func(context.Context, state.BeaconState, interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error)
-
-// RunBlockOperationTest takes in the prestate and the beacon block body, processes it through the
-// passed in block operation function and checks the post state with the expected post state.
-func RunBlockOperationTest(
-	t *testing.T,
-	folderPath string,
-	body *ethpb.BeaconBlockBodyCapella,
-	operationFn blockOperation,
-) {
-	preBeaconStateFile, err := util.BazelFileBytes(path.Join(folderPath, "pre.ssz_snappy"))
-	require.NoError(t, err)
-	preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
-	require.NoError(t, err, "Failed to decompress")
-	preStateBase := &ethpb.BeaconStateCapella{}
-	if err := preStateBase.UnmarshalSSZ(preBeaconStateSSZ); err != nil {
-		t.Fatalf("Failed to unmarshal: %v", err)
-	}
-	preState, err := state_native.InitializeFromProtoCapella(preStateBase)
-	require.NoError(t, err)
-
-	// If the post.ssz is not present, it means the test should fail on our end.
-	postSSZFilepath, err := bazel.Runfile(path.Join(folderPath, "post.ssz_snappy"))
-	postSSZExists := true
-	if err != nil && strings.Contains(err.Error(), "could not locate file") {
-		postSSZExists = false
-	} else if err != nil {
-		t.Fatal(err)
-	}
-
-	helpers.ClearCache()
-	b := util.NewBeaconBlockCapella()
-	b.Block.Body = body
-	wsb, err := blocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	beaconState, err := operationFn(context.Background(), preState, wsb)
-	if postSSZExists {
-		require.NoError(t, err)
-
-		postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
-		require.NoError(t, err)
-		postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
-		require.NoError(t, err, "Failed to decompress")
-
-		postBeaconState := &ethpb.BeaconStateCapella{}
-		if err := postBeaconState.UnmarshalSSZ(postBeaconStateSSZ); err != nil {
-			t.Fatalf("Failed to unmarshal: %v", err)
-		}
-		pbState, err := state_native.ProtobufBeaconStateCapella(beaconState.ToProtoUnsafe())
-		require.NoError(t, err)
-		if !proto.Equal(pbState, postBeaconState) {
-			t.Log(cmp.Diff(postBeaconState, pbState, protocmp.Transform()))
-			t.Fatal("Post state does not match expected")
-		}
-	} else {
-		// Note: This doesn't test anything worthwhile. It essentially tests
-		// that *any* error has occurred, not any specific error.
-		if err == nil {
-			t.Fatal("Did not fail when expected")
-		}
-		t.Logf("Expected failure; failure reason = %v", err)
-		return
+func sszToState(b []byte) (state.BeaconState, error) {
+	base := &ethpb.BeaconStateCapella{}
+	if err := base.UnmarshalSSZ(b); err != nil {
+		return nil, err
 	}
+	return state_native.InitializeFromProtoCapella(base)
+}
+
+func sszToBlock(b []byte) (interfaces.SignedBeaconBlock, error) {
+	base := &ethpb.BeaconBlockCapella{}
+	if err := base.UnmarshalSSZ(b); err != nil {
+		return nil, err
+	}
+	return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockCapella{Block: base})
+}
+
+func sszToBlockBody(b []byte) (interfaces.ReadOnlyBeaconBlockBody, error) {
+	base := &ethpb.BeaconBlockBodyCapella{}
+	if err := base.UnmarshalSSZ(b); err != nil {
+		return nil, err
+	}
+	return blocks.NewBeaconBlockBody(base)
 }

testing/spectest/shared/capella/operations/proposer_slashing.go

@@ -1,41 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunProposerSlashingTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "capella", "operations/proposer_slashing/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "capella", "operations/proposer_slashing/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			proposerSlashingFile, err := util.BazelFileBytes(folderPath, "proposer_slashing.ssz_snappy")
-			require.NoError(t, err)
-			proposerSlashingSSZ, err := snappy.Decode(nil /* dst */, proposerSlashingFile)
-			require.NoError(t, err, "Failed to decompress")
-			proposerSlashing := &ethpb.ProposerSlashing{}
-			require.NoError(t, proposerSlashing.UnmarshalSSZ(proposerSlashingSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyCapella{ProposerSlashings: []*ethpb.ProposerSlashing{proposerSlashing}}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return blocks.ProcessProposerSlashings(ctx, s, b.Block().Body().ProposerSlashings(), validators.SlashValidator)
-			})
-		})
+func blockWithProposerSlashing(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	ps := &ethpb.ProposerSlashing{}
+	if err := ps.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockCapella()
+	b.Block.Body = &ethpb.BeaconBlockBodyCapella{ProposerSlashings: []*ethpb.ProposerSlashing{ps}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunProposerSlashingTest(t *testing.T, config string) {
+	common.RunProposerSlashingTest(t, config, version.String(version.Capella), blockWithProposerSlashing, sszToState)
 }

testing/spectest/shared/capella/operations/sync_committee.go

@@ -1,44 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunSyncCommitteeTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "capella", "operations/sync_aggregate/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "capella", "operations/sync_aggregate/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			syncCommitteeFile, err := util.BazelFileBytes(folderPath, "sync_aggregate.ssz_snappy")
-			require.NoError(t, err)
-			syncCommitteeSSZ, err := snappy.Decode(nil /* dst */, syncCommitteeFile)
-			require.NoError(t, err, "Failed to decompress")
-			sc := &ethpb.SyncAggregate{}
-			require.NoError(t, sc.UnmarshalSSZ(syncCommitteeSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyCapella{SyncAggregate: sc}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				st, _, err := altair.ProcessSyncAggregate(context.Background(), s, body.SyncAggregate)
-				if err != nil {
-					return nil, err
-				}
-				return st, nil
-			})
-		})
+func blockWithSyncAggregate(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	sa := &ethpb.SyncAggregate{}
+	if err := sa.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockCapella()
+	b.Block.Body = &ethpb.BeaconBlockBodyCapella{SyncAggregate: sa}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunSyncCommitteeTest(t *testing.T, config string) {
+	common.RunSyncCommitteeTest(t, config, version.String(version.Capella), blockWithSyncAggregate, sszToState)
 }

testing/spectest/shared/capella/operations/voluntary_exit.go

@@ -1,40 +1,26 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunVoluntaryExitTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "capella", "operations/voluntary_exit/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "capella", "operations/voluntary_exit/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			exitFile, err := util.BazelFileBytes(folderPath, "voluntary_exit.ssz_snappy")
-			require.NoError(t, err)
-			exitSSZ, err := snappy.Decode(nil /* dst */, exitFile)
-			require.NoError(t, err, "Failed to decompress")
-			voluntaryExit := &ethpb.SignedVoluntaryExit{}
-			require.NoError(t, voluntaryExit.UnmarshalSSZ(exitSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyCapella{VoluntaryExits: []*ethpb.SignedVoluntaryExit{voluntaryExit}}
-			RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				return blocks.ProcessVoluntaryExits(ctx, s, b.Block().Body().VoluntaryExits())
-			})
-		})
+func blockWithVoluntaryExit(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	e := &ethpb.SignedVoluntaryExit{}
+	if err := e.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockCapella()
+	b.Block.Body = &ethpb.BeaconBlockBodyCapella{VoluntaryExits: []*ethpb.SignedVoluntaryExit{e}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunVoluntaryExitTest(t *testing.T, config string) {
+	common.RunVoluntaryExitTest(t, config, version.String(version.Capella), blockWithVoluntaryExit, sszToState)
 }

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

@@ -1,52 +1,27 @@
 package operations
 
 import (
-	"context"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunWithdrawalsTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "capella", "operations/withdrawals/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "capella", "operations/withdrawals/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			payloadFile, err := util.BazelFileBytes(folderPath, "execution_payload.ssz_snappy")
-			require.NoError(t, err)
-			payloadSSZ, err := snappy.Decode(nil /* dst */, payloadFile)
-			require.NoError(t, err, "Failed to decompress")
-			payload := &enginev1.ExecutionPayloadCapella{}
-			require.NoError(t, payload.UnmarshalSSZ(payloadSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyCapella{ExecutionPayload: payload}
-			RunBlockOperationTest(t, folderPath, body, func(_ context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-				payload, err := b.Block().Body().Execution()
-				if err != nil {
-					return nil, err
-				}
-				withdrawals, err := payload.Withdrawals()
-				if err != nil {
-					return nil, err
-				}
-				p, err := consensusblocks.WrappedExecutionPayloadCapella(&enginev1.ExecutionPayloadCapella{Withdrawals: withdrawals})
-				require.NoError(t, err)
-				return blocks.ProcessWithdrawals(s, p)
-			})
-		})
+func blockWithWithdrawals(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	e := &enginev1.ExecutionPayloadCapella{}
+	if err := e.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockCapella()
+	b.Block.Body = &ethpb.BeaconBlockBodyCapella{ExecutionPayload: e}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunWithdrawalsTest(t *testing.T, config string) {
+	common.RunWithdrawalsTest(t, config, version.String(version.Capella), blockWithWithdrawals, sszToState)
 }

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

@@ -0,0 +1,46 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    testonly = True,
+    srcs = [
+        "attestation.go",
+        "attester_slashing.go",
+        "block_header.go",
+        "bls_to_execution_changes.go",
+        "consolidations.go",
+        "deposit.go",
+        "deposit_request.go",
+        "execution_payload.go",
+        "proposer_slashing.go",
+        "slashing.go",
+        "sync_aggregate.go",
+        "test_runner.go",
+        "voluntary_exit.go",
+        "withdrawal_request.go",
+        "withdrawals.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/altair:go_default_library",
+        "//beacon-chain/core/blocks:go_default_library",
+        "//beacon-chain/core/electra:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/validators:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//consensus-types/blocks:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/spectest/utils:go_default_library",
+        "//testing/util:go_default_library",
+        "@com_github_golang_snappy//:go_default_library",
+        "@com_github_google_go_cmp//cmp:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@io_bazel_rules_go//go/tools/bazel:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
+        "@org_golang_google_protobuf//testing/protocmp:go_default_library",
+    ],
+)

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

@@ -0,0 +1,57 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"github.com/golang/snappy"
+	"github.com/pkg/errors"
+	b "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+// RunAttestationTest executes "operations/attestation" tests.
+func RunAttestationTest(t *testing.T, config string, fork string, blockWithAttestation blockWithSSZObject, processBlock ProcessBlock, sszToState SSZToState) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/attestation/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/attestation/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			folderPath := path.Join(testsFolderPath, folder.Name())
+			attestationFile, err := util.BazelFileBytes(folderPath, "attestation.ssz_snappy")
+			require.NoError(t, err)
+			attestationSSZ, err := snappy.Decode(nil /* dst */, attestationFile)
+			require.NoError(t, err, "Failed to decompress")
+			blk, err := blockWithAttestation(attestationSSZ)
+			require.NoError(t, err)
+
+			processAtt := func(ctx context.Context, st state.BeaconState, blk interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+				st, err = processBlock(ctx, st, blk.Block())
+				if err != nil {
+					return nil, err
+				}
+				aSet, err := b.AttestationSignatureBatch(ctx, st, blk.Block().Body().Attestations())
+				if err != nil {
+					return nil, err
+				}
+				verified, err := aSet.Verify()
+				if err != nil {
+					return nil, err
+				}
+				if !verified {
+					return nil, errors.New("could not batch verify attestation signature")
+				}
+				return st, nil
+			}
+
+			RunBlockOperationTest(t, folderPath, blk, sszToState, processAtt)
+		})
+	}
+}

testing/spectest/shared/common/operations/attester_slashing.go

@@ -0,0 +1,17 @@
+package operations
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	v "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+)
+
+func RunAttesterSlashingTest(t *testing.T, config string, fork string, block blockWithSSZObject, sszToState SSZToState) {
+	runSlashingTest(t, config, fork, "attester_slashing", block, sszToState, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+		return blocks.ProcessAttesterSlashings(ctx, s, b.Block().Body().AttesterSlashings(), v.SlashValidator)
+	})
+}

testing/spectest/shared/common/operations/block_header.go

@@ -0,0 +1,74 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"strings"
+	"testing"
+
+	"github.com/bazelbuild/rules_go/go/tools/bazel"
+	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+type SSZToBlock func([]byte) (interfaces.SignedBeaconBlock, error)
+
+func RunBlockHeaderTest(t *testing.T, config string, fork string, sszToBlock SSZToBlock, sszToState SSZToState) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/block_header/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/block_header/pyspec_tests")
+	}
+
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			helpers.ClearCache()
+
+			blockFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "block.ssz_snappy")
+			require.NoError(t, err)
+			blockSSZ, err := snappy.Decode(nil /* dst */, blockFile)
+			require.NoError(t, err, "Failed to decompress")
+			block, err := sszToBlock(blockSSZ)
+			require.NoError(t, err, "Failed to unmarshal")
+
+			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
+			require.NoError(t, err)
+			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
+			require.NoError(t, err, "Failed to decompress")
+			preBeaconState, err := sszToState(preBeaconStateSSZ)
+			require.NoError(t, err)
+
+			// If the post.ssz is not present, it means the test should fail on our end.
+			postSSZFilepath, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "post.ssz_snappy"))
+			postSSZExists := true
+			if err != nil && strings.Contains(err.Error(), "could not locate file") {
+				postSSZExists = false
+			} else {
+				require.NoError(t, err)
+			}
+
+			// Spectest blocks are not signed, so we'll call NoVerify to skip sig verification.
+			bodyRoot, err := block.Block().Body().HashTreeRoot()
+			require.NoError(t, err)
+			pr := block.Block().ParentRoot()
+			beaconState, err := blocks.ProcessBlockHeaderNoVerify(context.Background(), preBeaconState, block.Block().Slot(), block.Block().ProposerIndex(), pr[:], bodyRoot[:])
+			if postSSZExists {
+				require.NoError(t, err)
+				comparePostState(t, postSSZFilepath, sszToState, preBeaconState, beaconState)
+			} else {
+				// Note: This doesn't test anything worthwhile. It essentially tests
+				// that *any* error has occurred, not any specific error.
+				if err == nil {
+					t.Fatal("Did not fail when expected")
+				}
+				t.Logf("Expected failure; failure reason = %v", err)
+				return
+			}
+		})
+	}
+}

testing/spectest/shared/common/operations/bls_to_execution_changes.go

@@ -0,0 +1,57 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"github.com/golang/snappy"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func RunBLSToExecutionChangeTest(t *testing.T, config string, fork string, block blockWithSSZObject, sszToState SSZToState) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/bls_to_execution_change/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/bls_to_execution_change/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			folderPath := path.Join(testsFolderPath, folder.Name())
+			changeFile, err := util.BazelFileBytes(folderPath, "address_change.ssz_snappy")
+			require.NoError(t, err)
+			changeSSZ, err := snappy.Decode(nil /* dst */, changeFile)
+			require.NoError(t, err, "Failed to decompress")
+			blk, err := block(changeSSZ)
+			require.NoError(t, err)
+			RunBlockOperationTest(t, folderPath, blk, sszToState, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+				st, err := blocks.ProcessBLSToExecutionChanges(s, b.Block())
+				if err != nil {
+					return nil, err
+				}
+				changes, err := b.Block().Body().BLSToExecutionChanges()
+				if err != nil {
+					return nil, err
+				}
+				cSet, err := blocks.BLSChangesSignatureBatch(st, changes)
+				if err != nil {
+					return nil, err
+				}
+				ok, err := cSet.Verify()
+				if err != nil {
+					return nil, err
+				}
+				if !ok {
+					return nil, errors.New("signature did not verify")
+				}
+				return st, nil
+			})
+		})
+	}
+}

testing/spectest/shared/common/operations/consolidations.go

@@ -0,0 +1,43 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func RunConsolidationTest(t *testing.T, config string, fork string, block blockWithSSZObject, sszToState SSZToState) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/consolidation_request/pyspec_tests")
+	require.NotEqual(t, 0, len(testFolders), "missing tests for consolidation operation in folder")
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			folderPath := path.Join(testsFolderPath, folder.Name())
+			consolidationFile, err := util.BazelFileBytes(folderPath, "consolidation_request.ssz_snappy")
+			require.NoError(t, err)
+			consolidationSSZ, err := snappy.Decode(nil /* dst */, consolidationFile)
+			require.NoError(t, err, "Failed to decompress")
+			blk, err := block(consolidationSSZ)
+			require.NoError(t, err)
+			RunBlockOperationTest(t, folderPath, blk, sszToState, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+				ed, err := b.Block().Body().Execution()
+				if err != nil {
+					return nil, err
+				}
+				eed, ok := ed.(interfaces.ExecutionDataElectra)
+				if !ok {
+					t.Fatal("block does not have execution data for electra")
+				}
+				return s, electra.ProcessConsolidationRequests(ctx, s, eed.ConsolidationRequests())
+			})
+		})
+	}
+}

testing/spectest/shared/common/operations/deposit.go

@@ -0,0 +1,36 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+type ProcessDeposits func(ctx context.Context, beaconState state.BeaconState, deposits []*ethpb.Deposit) (state.BeaconState, error)
+
+func RunDepositTest(t *testing.T, config string, fork string, blockWithDeposit blockWithSSZObject, process ProcessDeposits, sszToState SSZToState) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/deposit/pyspec_tests")
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			folderPath := path.Join(testsFolderPath, folder.Name())
+			depositFile, err := util.BazelFileBytes(folderPath, "deposit.ssz_snappy")
+			require.NoError(t, err)
+			depositSSZ, err := snappy.Decode(nil /* dst */, depositFile)
+			require.NoError(t, err, "Failed to decompress")
+			blk, err := blockWithDeposit(depositSSZ)
+			require.NoError(t, err)
+			RunBlockOperationTest(t, folderPath, blk, sszToState, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+				return process(ctx, s, b.Block().Body().Deposits())
+			})
+		})
+	}
+}

testing/spectest/shared/common/operations/deposit_request.go

@@ -0,0 +1,38 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func RunDepositRequestsTest(t *testing.T, config string, fork string, block blockWithSSZObject, sszToState SSZToState) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, "electra", "operations/deposit_request/pyspec_tests")
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			folderPath := path.Join(testsFolderPath, folder.Name())
+			depositRequestFile, err := util.BazelFileBytes(folderPath, "deposit_request.ssz_snappy")
+			require.NoError(t, err)
+			depositRequestSSZ, err := snappy.Decode(nil /* dst */, depositRequestFile)
+			require.NoError(t, err, "Failed to decompress")
+			blk, err := block(depositRequestSSZ)
+			require.NoError(t, err)
+			RunBlockOperationTest(t, folderPath, blk, sszToState, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+				e, err := b.Block().Body().Execution()
+				require.NoError(t, err, "Failed to get execution")
+				ee, ok := e.(interfaces.ExecutionDataElectra)
+				require.Equal(t, true, ok, "Invalid execution payload")
+				return electra.ProcessDepositRequests(ctx, s, ee.DepositRequests())
+			})
+		})
+	}
+}

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

@@ -0,0 +1,76 @@
+package operations
+
+import (
+	"path"
+	"strings"
+	"testing"
+
+	"github.com/bazelbuild/rules_go/go/tools/bazel"
+	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+type SSZToBlockBody func([]byte) (interfaces.ReadOnlyBeaconBlockBody, error)
+
+func RunExecutionPayloadTest(t *testing.T, config string, fork string, sszToBlockBody SSZToBlockBody, sszToState SSZToState) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/execution_payload/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/execution_payload/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			helpers.ClearCache()
+
+			blockBodyFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "body.ssz_snappy")
+			require.NoError(t, err)
+			bodySSZ, err := snappy.Decode(nil /* dst */, blockBodyFile)
+			require.NoError(t, err, "Failed to decompress")
+			body, err := sszToBlockBody(bodySSZ)
+			require.NoError(t, err, "Failed to unmarshal")
+
+			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
+			require.NoError(t, err)
+			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
+			require.NoError(t, err, "Failed to decompress")
+			preBeaconState, err := sszToState(preBeaconStateSSZ)
+			require.NoError(t, err)
+
+			postSSZFilepath, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "post.ssz_snappy"))
+			postSSZExists := true
+			if err != nil && strings.Contains(err.Error(), "could not locate file") {
+				postSSZExists = false
+			} else {
+				require.NoError(t, err)
+			}
+
+			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "execution.yaml")
+			require.NoError(t, err)
+			config := &ExecutionConfig{}
+			require.NoError(t, utils.UnmarshalYaml(file, config), "Failed to Unmarshal")
+
+			gotState, err := blocks.ProcessPayload(preBeaconState, body)
+			if postSSZExists {
+				require.NoError(t, err)
+				comparePostState(t, postSSZFilepath, sszToState, preBeaconState, gotState)
+			} else if config.Valid {
+				// Note: This doesn't test anything worthwhile. It essentially tests
+				// that *any* error has occurred, not any specific error.
+				if err == nil {
+					t.Fatal("Did not fail when expected")
+				}
+				t.Logf("Expected failure; failure reason = %v", err)
+				return
+			}
+		})
+	}
+}
+
+type ExecutionConfig struct {
+	Valid bool `json:"execution_valid"`
+}

testing/spectest/shared/common/operations/proposer_slashing.go

@@ -0,0 +1,17 @@
+package operations
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	v "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+)
+
+func RunProposerSlashingTest(t *testing.T, config string, fork string, block blockWithSSZObject, sszToState SSZToState) {
+	runSlashingTest(t, config, fork, "proposer_slashing", block, sszToState, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+		return blocks.ProcessProposerSlashings(ctx, s, b.Block().Body().ProposerSlashings(), v.SlashValidator)
+	})
+}

testing/spectest/shared/common/operations/slashing.go

@@ -0,0 +1,31 @@
+package operations
+
+import (
+	"path"
+	"testing"
+
+	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func runSlashingTest(t *testing.T, config string, fork string, objName string, block blockWithSSZObject, sszToState SSZToState, operationFn BlockOperation) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/"+objName+"/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/"+objName+"/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			folderPath := path.Join(testsFolderPath, folder.Name())
+			slashingFile, err := util.BazelFileBytes(folderPath, objName+".ssz_snappy")
+			require.NoError(t, err)
+			slashingSSZ, err := snappy.Decode(nil /* dst */, slashingFile)
+			require.NoError(t, err, "Failed to decompress")
+			blk, err := block(slashingSSZ)
+			require.NoError(t, err)
+			RunBlockOperationTest(t, folderPath, blk, sszToState, operationFn)
+		})
+	}
+}

testing/spectest/shared/common/operations/sync_aggregate.go

@@ -0,0 +1,45 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func RunSyncCommitteeTest(t *testing.T, config string, fork string, block blockWithSSZObject, sszToState SSZToState) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/sync_aggregate/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/sync_aggregate/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			folderPath := path.Join(testsFolderPath, folder.Name())
+			f, err := util.BazelFileBytes(folderPath, "sync_aggregate.ssz_snappy")
+			require.NoError(t, err)
+			ssz, err := snappy.Decode(nil /* dst */, f)
+			require.NoError(t, err, "Failed to decompress")
+			blk, err := block(ssz)
+			require.NoError(t, err)
+			RunBlockOperationTest(t, folderPath, blk, sszToState, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+				sa, err := b.Block().Body().SyncAggregate()
+				if err != nil {
+					return nil, err
+				}
+				st, _, err := altair.ProcessSyncAggregate(context.Background(), s, sa)
+				if err != nil {
+					return nil, err
+				}
+				return st, nil
+			})
+		})
+	}
+}

testing/spectest/shared/common/operations/test_runner.go

@@ -0,0 +1,83 @@
+package operations
+
+import (
+	"context"
+	"os"
+	"path"
+	"strings"
+	"testing"
+
+	"github.com/bazelbuild/rules_go/go/tools/bazel"
+	"github.com/golang/snappy"
+	"github.com/google/go-cmp/cmp"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/testing/protocmp"
+)
+
+type blockWithSSZObject func([]byte) (interfaces.SignedBeaconBlock, error)
+type BlockOperation func(context.Context, state.BeaconState, interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error)
+type ProcessBlock func(context.Context, state.BeaconState, interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error)
+type SSZToState func([]byte) (state.BeaconState, error)
+
+// RunBlockOperationTest takes in the prestate and the beacon block body, processes it through the
+// passed in block operation function and checks the post state with the expected post state.
+func RunBlockOperationTest(
+	t *testing.T,
+	folderPath string,
+	wsb interfaces.SignedBeaconBlock,
+	sszToState SSZToState,
+	operationFn BlockOperation,
+) {
+	preBeaconStateFile, err := util.BazelFileBytes(path.Join(folderPath, "pre.ssz_snappy"))
+	require.NoError(t, err)
+	preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
+	require.NoError(t, err, "Failed to decompress")
+	preState, err := sszToState(preBeaconStateSSZ)
+	require.NoError(t, err)
+
+	// If the post.ssz is not present, it means the test should fail on our end.
+	postSSZFilepath, err := bazel.Runfile(path.Join(folderPath, "post.ssz_snappy"))
+	postSSZExists := true
+	if err != nil && strings.Contains(err.Error(), "could not locate file") {
+		postSSZExists = false
+	} else if err != nil {
+		t.Fatal(err)
+	}
+
+	helpers.ClearCache()
+	beaconState, err := operationFn(context.Background(), preState, wsb)
+	if postSSZExists {
+		require.NoError(t, err)
+		comparePostState(t, postSSZFilepath, sszToState, preState, beaconState)
+	} else {
+		// Note: This doesn't test anything worthwhile. It essentially tests
+		// that *any* error has occurred, not any specific error.
+		if err == nil {
+			t.Fatal("Did not fail when expected")
+		}
+		t.Logf("Expected failure; failure reason = %v", err)
+		return
+	}
+}
+
+func comparePostState(t *testing.T, postSSZFilepath string, sszToState SSZToState, want state.BeaconState, got state.BeaconState) {
+	postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
+	require.NoError(t, err)
+	postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
+	require.NoError(t, err, "Failed to decompress")
+	postBeaconState, err := sszToState(postBeaconStateSSZ)
+	require.NoError(t, err)
+	postBeaconStatePb, ok := postBeaconState.ToProtoUnsafe().(proto.Message)
+	require.Equal(t, true, ok, "post beacon state did not return a proto.Message")
+	pbState, ok := want.ToProtoUnsafe().(proto.Message)
+	require.Equal(t, true, ok, "beacon state did not return a proto.Message")
+	if !proto.Equal(pbState, postBeaconStatePb) {
+		t.Log(cmp.Diff(postBeaconStatePb, pbState, protocmp.Transform()))
+		t.Fatal("Post state does not match expected")
+	}
+}

testing/spectest/shared/common/operations/voluntary_exit.go

@@ -0,0 +1,37 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func RunVoluntaryExitTest(t *testing.T, config string, fork string, block blockWithSSZObject, sszToState SSZToState) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/voluntary_exit/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/voluntary_exit/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			folderPath := path.Join(testsFolderPath, folder.Name())
+			exitFile, err := util.BazelFileBytes(folderPath, "voluntary_exit.ssz_snappy")
+			require.NoError(t, err)
+			exitSSZ, err := snappy.Decode(nil /* dst */, exitFile)
+			require.NoError(t, err, "Failed to decompress")
+			blk, err := block(exitSSZ)
+			require.NoError(t, err)
+			RunBlockOperationTest(t, folderPath, blk, sszToState, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+				return blocks.ProcessVoluntaryExits(ctx, s, b.Block().Body().VoluntaryExits())
+			})
+		})
+	}
+}

testing/spectest/shared/common/operations/withdrawal_request.go

@@ -0,0 +1,42 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func RunWithdrawalRequestTest(t *testing.T, config string, fork string, block blockWithSSZObject, sszToState SSZToState) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/withdrawal_request/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/withdrawal_request/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			folderPath := path.Join(testsFolderPath, folder.Name())
+			withdrawalRequestFile, err := util.BazelFileBytes(folderPath, "withdrawal_request.ssz_snappy")
+			require.NoError(t, err)
+			withdrawalRequestSSZ, err := snappy.Decode(nil /* dst */, withdrawalRequestFile)
+			require.NoError(t, err, "Failed to decompress")
+			blk, err := block(withdrawalRequestSSZ)
+			require.NoError(t, err)
+			RunBlockOperationTest(t, folderPath, blk, sszToState, func(ctx context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+				bod := b.Block().Body()
+				e, err := bod.Execution()
+				require.NoError(t, err)
+				exe, ok := e.(interfaces.ExecutionDataElectra)
+				require.Equal(t, true, ok)
+				return electra.ProcessWithdrawalRequests(ctx, s, exe.WithdrawalRequests())
+			})
+		})
+	}
+}

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

@@ -0,0 +1,50 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func RunWithdrawalsTest(t *testing.T, config string, fork string, sszToBlock SSZToBlock, sszToState SSZToState) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/withdrawals/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/withdrawals/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			folderPath := path.Join(testsFolderPath, folder.Name())
+			payloadFile, err := util.BazelFileBytes(folderPath, "execution_payload.ssz_snappy")
+			require.NoError(t, err)
+			payloadSSZ, err := snappy.Decode(nil /* dst */, payloadFile)
+			require.NoError(t, err, "Failed to decompress")
+			blk, err := sszToBlock(payloadSSZ)
+			require.NoError(t, err)
+
+			RunBlockOperationTest(t, folderPath, blk, sszToState, func(_ context.Context, s state.BeaconState, b interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+				payload, err := b.Block().Body().Execution()
+				if err != nil {
+					return nil, err
+				}
+				withdrawals, err := payload.Withdrawals()
+				if err != nil {
+					return nil, err
+				}
+				p, err := consensusblocks.WrappedExecutionPayloadCapella(&enginev1.ExecutionPayloadCapella{Withdrawals: withdrawals})
+				require.NoError(t, err)
+				return blocks.ProcessWithdrawals(s, p)
+			})
+		})
+	}
+}

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

@@ -20,22 +20,14 @@ go_library(
     visibility = ["//testing/spectest:__subpackages__"],
     deps = [
         "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/blocks:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
-        "//beacon-chain/core/validators: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/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/spectest/utils:go_default_library",
+        "//runtime/version:go_default_library",
+        "//testing/spectest/shared/common/operations:go_default_library",
         "//testing/util:go_default_library",
-        "@com_github_golang_snappy//:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@io_bazel_rules_go//go/tools/bazel:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

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

@@ -1,56 +1,27 @@
 package operations
 
 import (
-	"context"
-	"errors"
-	"path"
 	"testing"
 
-	"github.com/golang/snappy"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	b "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	common "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/common/operations"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func RunAttestationTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "deneb", "operations/attestation/pyspec_tests")
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			attestationFile, err := util.BazelFileBytes(folderPath, "attestation.ssz_snappy")
-			require.NoError(t, err)
-			attestationSSZ, err := snappy.Decode(nil /* dst */, attestationFile)
-			require.NoError(t, err, "Failed to decompress")
-			att := &ethpb.Attestation{}
-			require.NoError(t, att.UnmarshalSSZ(attestationSSZ), "Failed to unmarshal")
-
-			body := &ethpb.BeaconBlockBodyDeneb{Attestations: []*ethpb.Attestation{att}}
-			processAtt := func(ctx context.Context, st state.BeaconState, blk interfaces.SignedBeaconBlock) (state.BeaconState, error) {
-				st, err = altair.ProcessAttestationsNoVerifySignature(ctx, st, blk.Block())
-				if err != nil {
-					return nil, err
-				}
-				aSet, err := b.AttestationSignatureBatch(ctx, st, blk.Block().Body().Attestations())
-				if err != nil {
-					return nil, err
-				}
-				verified, err := aSet.Verify()
-				if err != nil {
-					return nil, err
-				}
-				if !verified {
-					return nil, errors.New("could not batch verify attestation signature")
-				}
-				return st, nil
-			}
-
-			RunBlockOperationTest(t, folderPath, body, processAtt)
-		})
+func blockWithAttestation(attestationSSZ []byte) (interfaces.SignedBeaconBlock, error) {
+	att := &ethpb.Attestation{}
+	if err := att.UnmarshalSSZ(attestationSSZ); err != nil {
+		return nil, err
 	}
+	b := util.NewBeaconBlockDeneb()
+	b.Block.Body = &ethpb.BeaconBlockBodyDeneb{Attestations: []*ethpb.Attestation{att}}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunAttestationTest(t *testing.T, config string) {
+	common.RunAttestationTest(t, config, version.String(version.Deneb), blockWithAttestation, altair.ProcessAttestationsNoVerifySignature, sszToState)
 }