refactor

changelog/james-prysm_deflake-evaluator.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- adding some short retries for some end to end evaluators in an attempt to deflake tests.

changelog/jtraglia-add-specrefs-readme.md

@@ -1,3 +0,0 @@
-### Added
-
-- Added README for maintaining specrefs.

changelog/jtraglia-nightly-reftests-with-run-id.md

@@ -1,3 +0,0 @@
-### Added
-
-- The ability to download the nightly reference tests from a specific day.

specrefs/README.md

@@ -1,35 +0,0 @@
-# Specification References
-
-This directory contains specification reference tracking files managed by
-[ethspecify](https://github.com/jtraglia/ethspecify).
-
-## Installation
-
-Install `ethspecify` with the following command:
-
-```bash
-pipx install ethspecify
-```
-
-> [!NOTE]
-> You can run `ethspecify <cmd>` in the `specrefs` directory or
-> `ethspecify <cmd> --path=specrefs` from the project's root directory.
-
-## Maintenance
-
-When adding support for a new specification version, follow these steps:
-
-0. Change directory into the `specrefs` directory.
-1. Update the version in `.ethspecify.yml` configuration.
-2. Run `ethspecify process` to update/populate specrefs.
-3. Run `ethspecify check` to check specrefs.
-4. If there are errors, use the error message as a guide to fix the issue. If
-   there are new specrefs with empty sources, implement/locate each item and
-   update each specref source list. If you choose not to implement an item,
-   add an exception to the appropriate section the the `.ethspecify.yml`
-   configuration.
-5. Repeat steps 3 and 4 until `ethspecify check` passes.
-6. Run `git diff` to view updated specrefs. If an object/function/etc has
-   changed, make the necessary updates to the implementation.
-7. Lastly, in the project's root directory, run `act -j check-specrefs` to
-   ensure everything is correct.

testing/endtoend/components/eth1/transactions.go

@@ -40,7 +40,6 @@ type TransactionGenerator struct {
 	cancel        context.CancelFunc
 	paused        bool
 	useLargeBlobs bool // Use large blob transactions (6 blobs per tx) for BPO testing
-	blobTxCount   int  // Number of blob transactions per slot (0 means default of 5)
 }
 
 func (t *TransactionGenerator) UnderlyingProcess() *os.Process {
@@ -49,8 +48,8 @@ func (t *TransactionGenerator) UnderlyingProcess() *os.Process {
 	return &os.Process{}
 }
 
-func NewTransactionGenerator(keystore string, seed int64, useLargeBlobs bool, blobTxCount int) *TransactionGenerator {
-	return &TransactionGenerator{keystore: keystore, seed: seed, useLargeBlobs: useLargeBlobs, blobTxCount: blobTxCount}
+func NewTransactionGenerator(keystore string, seed int64, useLargeBlobs bool) *TransactionGenerator {
+	return &TransactionGenerator{keystore: keystore, seed: seed, useLargeBlobs: useLargeBlobs}
 }
 
 func (t *TransactionGenerator) Start(ctx context.Context) error {
@@ -115,7 +114,7 @@ func (t *TransactionGenerator) Start(ctx context.Context) error {
 				continue
 			}
 			backend := ethclient.NewClient(client)
-			err = SendTransaction(client, mineKey.PrivateKey, gasPrice, mineKey.Address.String(), txCount, backend, false, t.useLargeBlobs, t.blobTxCount)
+			err = SendTransaction(client, mineKey.PrivateKey, gasPrice, mineKey.Address.String(), txCount, backend, false, t.useLargeBlobs)
 			if err != nil {
 				return err
 			}
@@ -129,7 +128,7 @@ func (s *TransactionGenerator) Started() <-chan struct{} {
 	return s.started
 }
 
-func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.Int, addr string, txCount uint64, backend *ethclient.Client, al bool, useLargeBlobs bool, blobTxCount int) error {
+func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.Int, addr string, txCount uint64, backend *ethclient.Client, al bool, useLargeBlobs bool) error {
 	sender := common.HexToAddress(addr)
 	nonce, err := backend.PendingNonceAt(context.Background(), fundedAccount.Address)
 	if err != nil {
@@ -151,19 +150,14 @@ func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.In
 	clock := startup.NewClock(e2e.TestParams.CLGenesisTime, [32]byte{})
 	isPostFulu := clock.CurrentEpoch() >= params.BeaconConfig().FuluForkEpoch
 
-	// Default to 5 blob transactions per slot if not configured.
-	numBlobTxs := blobTxCount
-	if numBlobTxs <= 0 {
-		numBlobTxs = 5
-	}
-
 	g, _ := errgroup.WithContext(context.Background())
-	txs := make([]*types.Transaction, numBlobTxs)
+	txs := make([]*types.Transaction, 10)
 
 	// Send blob transactions - use different versions pre/post Fulu
 	if isPostFulu {
 		logrus.Info("Sending blob transactions with cell proofs")
-		for index := range uint64(numBlobTxs) {
+		// Reduced from 10 to 5 to reduce load and prevent builder/EL timeouts
+		for index := range uint64(5) {
 
 			g.Go(func() error {
 				tx, err := RandomBlobCellTx(client, fundedAccount.Address, nonce+index, gasPrice, chainid, al, useLargeBlobs)
@@ -182,7 +176,8 @@ func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.In
 		}
 	} else {
 		logrus.Info("Sending blob transactions with sidecars")
-		for index := range uint64(numBlobTxs) {
+		// Reduced from 10 to 5 to reduce load and prevent builder/EL timeouts
+		for index := range uint64(5) {
 
 			g.Go(func() error {
 				tx, err := RandomBlobTx(client, fundedAccount.Address, nonce+index, gasPrice, chainid, al, useLargeBlobs)

testing/endtoend/endtoend_test.go

@@ -225,9 +225,9 @@ func (r *testRunner) testDepositsAndTx(ctx context.Context, g *errgroup.Group,
 		if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{r.depositor}); err != nil {
 			return errors.Wrap(err, "testDepositsAndTx unable to run, depositor did not Start")
 		}
-		go func() {
-			if r.config.TestDeposits {
-				log.Info("Running deposit tests")
+        go func() {
+            if r.config.TestDeposits {
+                log.Info("Running deposit tests")
 				// The validators with an index < minGenesisActiveCount all have deposits already from the chain start.
 				// Skip all of those chain start validators by seeking to minGenesisActiveCount in the validator list
 				// for further deposit testing.
@@ -238,12 +238,12 @@ func (r *testRunner) testDepositsAndTx(ctx context.Context, g *errgroup.Group,
 						r.t.Error(errors.Wrap(err, "depositor.SendAndMine failed"))
 					}
 				}
-			}
-			// Only generate background transactions when relevant for the test.
-			if r.config.TestDeposits || r.config.TestFeature || r.config.UseBuilder {
-				r.testTxGeneration(ctx, g, keystorePath, []e2etypes.ComponentRunner{})
-			}
-		}()
+            }
+            // Only generate background transactions when relevant for the test.
+            if r.config.TestDeposits || r.config.TestFeature || r.config.UseBuilder {
+                r.testTxGeneration(ctx, g, keystorePath, []e2etypes.ComponentRunner{})
+            }
+        }()
 		if r.config.TestDeposits {
 			return depositCheckValidator.Start(ctx)
 		}
@@ -252,7 +252,7 @@ func (r *testRunner) testDepositsAndTx(ctx context.Context, g *errgroup.Group,
 }
 
 func (r *testRunner) testTxGeneration(ctx context.Context, g *errgroup.Group, keystorePath string, requiredNodes []e2etypes.ComponentRunner) {
-	txGenerator := eth1.NewTransactionGenerator(keystorePath, r.config.Seed, r.config.UseLargeBlobs, r.config.BlobTxCount)
+	txGenerator := eth1.NewTransactionGenerator(keystorePath, r.config.Seed, r.config.UseLargeBlobs)
 	r.comHandler.txGen = txGenerator
 	g.Go(func() error {
 		if err := helpers.ComponentsStarted(ctx, requiredNodes); err != nil {

testing/endtoend/evaluators/node.go

@@ -156,9 +156,19 @@ func waitForMidEpoch(conn *grpc.ClientConn) error {
 	}
 }
 
-// getHeadEpochs fetches the head epoch from all beacon nodes concurrently.
-func getHeadEpochs(conns []*grpc.ClientConn) ([]primitives.Epoch, error) {
-	epochs := make([]primitives.Epoch, len(conns))
+func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) error {
+	// Wait until we're at least halfway into the epoch to avoid race conditions
+	// at epoch boundaries where nodes may report different epochs.
+	if err := waitForMidEpoch(conns[0]); err != nil {
+		return errors.Wrap(err, "failed waiting for mid-epoch")
+	}
+
+	headEpochs := make([]primitives.Epoch, len(conns))
+	headBlockRoots := make([][]byte, len(conns))
+	justifiedRoots := make([][]byte, len(conns))
+	prevJustifiedRoots := make([][]byte, len(conns))
+	finalizedRoots := make([][]byte, len(conns))
+	chainHeads := make([]*eth.ChainHead, len(conns))
 	g, _ := errgroup.WithContext(context.Background())
 
 	for i, conn := range conns {
@@ -170,145 +180,63 @@ func getHeadEpochs(conns []*grpc.ClientConn) ([]primitives.Epoch, error) {
 			if err != nil {
 				return errors.Wrapf(err, "connection number=%d", conIdx)
 			}
-			epochs[conIdx] = chainHead.HeadEpoch
+			headEpochs[conIdx] = chainHead.HeadEpoch
+			headBlockRoots[conIdx] = chainHead.HeadBlockRoot
+			justifiedRoots[conIdx] = chainHead.JustifiedBlockRoot
+			prevJustifiedRoots[conIdx] = chainHead.PreviousJustifiedBlockRoot
+			finalizedRoots[conIdx] = chainHead.FinalizedBlockRoot
+			chainHeads[conIdx] = chainHead
 			return nil
 		})
 	}
 	if err := g.Wait(); err != nil {
-		return nil, err
+		return err
 	}
-	return epochs, nil
-}
-
-func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) error {
-	// Wait until we're at least halfway into the epoch to avoid race conditions
-	// at epoch boundaries where nodes may report different epochs.
-	if err := waitForMidEpoch(conns[0]); err != nil {
-		return errors.Wrap(err, "failed waiting for mid-epoch")
-	}
-
-	// First, wait for all nodes to reach the same epoch. Sync nodes may be
-	// behind and need time to catch up. We poll every 2 seconds with a
-	// 60 second timeout - this adapts to actual sync progress rather than
-	// using fixed delays.
-	const epochTimeout = 60 * time.Second
-	const epochPollInterval = 2 * time.Second
-	epochDeadline := time.Now().Add(epochTimeout)
-
-	for time.Now().Before(epochDeadline) {
-		epochs, err := getHeadEpochs(conns)
-		if err != nil {
-			return err
-		}
-		allSame := true
-		for i := 1; i < len(epochs); i++ {
-			if epochs[0] != epochs[i] {
-				allSame = false
-				break
-			}
-		}
-		if allSame {
-			break
-		}
-		time.Sleep(epochPollInterval)
-	}
-
-	// Now that epochs match (or timeout reached), do detailed head comparison
-	// with a few retries to handle block propagation delays.
-	const maxRetries = 5
-	const retryDelay = 1 * time.Second
-	var lastErr error
-
-	for attempt := range maxRetries {
-		if attempt > 0 {
-			time.Sleep(retryDelay)
-		}
-
-		headEpochs := make([]primitives.Epoch, len(conns))
-		headBlockRoots := make([][]byte, len(conns))
-		justifiedRoots := make([][]byte, len(conns))
-		prevJustifiedRoots := make([][]byte, len(conns))
-		finalizedRoots := make([][]byte, len(conns))
-		chainHeads := make([]*eth.ChainHead, len(conns))
-		g, _ := errgroup.WithContext(context.Background())
-
-		for i, conn := range conns {
-			conIdx := i
-			currConn := conn
-			g.Go(func() error {
-				beaconClient := eth.NewBeaconChainClient(currConn)
-				chainHead, err := beaconClient.GetChainHead(context.Background(), &emptypb.Empty{})
-				if err != nil {
-					return errors.Wrapf(err, "connection number=%d", conIdx)
-				}
-				headEpochs[conIdx] = chainHead.HeadEpoch
-				headBlockRoots[conIdx] = chainHead.HeadBlockRoot
-				justifiedRoots[conIdx] = chainHead.JustifiedBlockRoot
-				prevJustifiedRoots[conIdx] = chainHead.PreviousJustifiedBlockRoot
-				finalizedRoots[conIdx] = chainHead.FinalizedBlockRoot
-				chainHeads[conIdx] = chainHead
-				return nil
-			})
-		}
-		if err := g.Wait(); err != nil {
-			return err
-		}
-
-		lastErr = nil
-		for i := range conns {
-			if headEpochs[0] != headEpochs[i] {
-				lastErr = fmt.Errorf(
-					"received conflicting head epochs on node %d, expected %d, received %d",
-					i,
-					headEpochs[0],
-					headEpochs[i],
-				)
-				break
-			}
-			if !bytes.Equal(headBlockRoots[0], headBlockRoots[i]) {
-				lastErr = fmt.Errorf(
-					"received conflicting head block roots on node %d, expected %#x, received %#x",
-					i,
-					headBlockRoots[0],
-					headBlockRoots[i],
-				)
-				break
-			}
-			if !bytes.Equal(justifiedRoots[0], justifiedRoots[i]) {
-				lastErr = fmt.Errorf(
-					"received conflicting justified block roots on node %d, expected %#x, received %#x: %s and %s",
-					i,
-					justifiedRoots[0],
-					justifiedRoots[i],
-					chainHeads[0].String(),
-					chainHeads[i].String(),
-				)
-				break
-			}
-			if !bytes.Equal(prevJustifiedRoots[0], prevJustifiedRoots[i]) {
-				lastErr = fmt.Errorf(
-					"received conflicting previous justified block roots on node %d, expected %#x, received %#x",
-					i,
-					prevJustifiedRoots[0],
-					prevJustifiedRoots[i],
-				)
-				break
-			}
-			if !bytes.Equal(finalizedRoots[0], finalizedRoots[i]) {
-				lastErr = fmt.Errorf(
-					"received conflicting finalized epoch roots on node %d, expected %#x, received %#x",
-					i,
-					finalizedRoots[0],
-					finalizedRoots[i],
-				)
-				break
-			}
-		}
-
-		if lastErr == nil {
-			return nil
-		}
-	}
-
-	return lastErr
+
+	for i := range conns {
+		if headEpochs[0] != headEpochs[i] {
+			return fmt.Errorf(
+				"received conflicting head epochs on node %d, expected %d, received %d",
+				i,
+				headEpochs[0],
+				headEpochs[i],
+			)
+		}
+		if !bytes.Equal(headBlockRoots[0], headBlockRoots[i]) {
+			return fmt.Errorf(
+				"received conflicting head block roots on node %d, expected %#x, received %#x",
+				i,
+				headBlockRoots[0],
+				headBlockRoots[i],
+			)
+		}
+		if !bytes.Equal(justifiedRoots[0], justifiedRoots[i]) {
+			return fmt.Errorf(
+				"received conflicting justified block roots on node %d, expected %#x, received %#x: %s and %s",
+				i,
+				justifiedRoots[0],
+				justifiedRoots[i],
+				chainHeads[0].String(),
+				chainHeads[i].String(),
+			)
+		}
+		if !bytes.Equal(prevJustifiedRoots[0], prevJustifiedRoots[i]) {
+			return fmt.Errorf(
+				"received conflicting previous justified block roots on node %d, expected %#x, received %#x",
+				i,
+				prevJustifiedRoots[0],
+				prevJustifiedRoots[i],
+			)
+		}
+		if !bytes.Equal(finalizedRoots[0], finalizedRoots[i]) {
+			return fmt.Errorf(
+				"received conflicting finalized epoch roots on node %d, expected %#x, received %#x",
+				i,
+				finalizedRoots[0],
+				finalizedRoots[i],
+			)
+		}
+	}
+
+	return nil
 }

testing/endtoend/evaluators/validator.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"net/http"
 	"strconv"
-	"time"
 
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/altair"
@@ -124,25 +123,6 @@ func validatorsAreActive(ec *types.EvaluationContext, conns ...*grpc.ClientConn)
 
 // validatorsParticipating ensures the validators have an acceptable participation rate.
 func validatorsParticipating(_ *types.EvaluationContext, conns ...*grpc.ClientConn) error {
-	// Retry up to 3 times with 2 second delays to handle timing flakes where
-	// attestations haven't been fully processed yet due to block propagation delays.
-	const maxRetries = 3
-	const retryDelay = 2 * time.Second
-	var lastErr error
-
-	for attempt := range maxRetries {
-		if attempt > 0 {
-			time.Sleep(retryDelay)
-		}
-		lastErr = checkValidatorsParticipating(conns)
-		if lastErr == nil {
-			return nil
-		}
-	}
-	return lastErr
-}
-
-func checkValidatorsParticipating(conns []*grpc.ClientConn) error {
 	conn := conns[0]
 	client := ethpb.NewBeaconChainClient(conn)
 	validatorRequest := &ethpb.GetValidatorParticipationRequest{}
@@ -254,25 +234,6 @@ func checkValidatorsParticipating(conns []*grpc.ClientConn) error {
 // validatorsSyncParticipation ensures the validators have an acceptable participation rate for
 // sync committee assignments.
 func validatorsSyncParticipation(_ *types.EvaluationContext, conns ...*grpc.ClientConn) error {
-	// Retry up to 3 times with 2 second delays to handle timing flakes where
-	// sync committee messages haven't fully propagated yet.
-	const maxRetries = 3
-	const retryDelay = 2 * time.Second
-	var lastErr error
-
-	for attempt := range maxRetries {
-		if attempt > 0 {
-			time.Sleep(retryDelay)
-		}
-		lastErr = checkSyncParticipation(conns)
-		if lastErr == nil {
-			return nil
-		}
-	}
-	return lastErr
-}
-
-func checkSyncParticipation(conns []*grpc.ClientConn) error {
 	conn := conns[0]
 	client := ethpb.NewNodeClient(conn)
 	altairClient := ethpb.NewBeaconChainClient(conn)
@@ -311,9 +272,9 @@ func checkSyncParticipation(conns []*grpc.ClientConn) error {
 			// Skip fork slot.
 			continue
 		}
-		// Skip early slots at genesis - validators need time to ramp up after chain start
+		// Skip slots 1-2 at genesis - validators need time to ramp up after chain start
 		// due to doppelganger protection. This is a startup timing issue, not a fork transition issue.
-		if b.Block().Slot() < 5 {
+		if b.Block().Slot() < 3 {
 			continue
 		}
 		expectedParticipation := expectedSyncParticipation
@@ -328,11 +289,6 @@ func checkSyncParticipation(conns []*grpc.ClientConn) error {
 		if err != nil {
 			return err
 		}
-		// Skip blocks with zero sync bits - these are typically empty/anomalous blocks
-		// where the proposer didn't receive sync committee contributions in time.
-		if syncAgg.SyncCommitteeBits.Count() == 0 {
-			continue
-		}
 		threshold := uint64(float64(syncAgg.SyncCommitteeBits.Len()) * expectedParticipation)
 		if syncAgg.SyncCommitteeBits.Count() < threshold {
 			return errors.Errorf("In block of slot %d ,the aggregate bitvector with length of %d only got a count of %d", b.Block().Slot(), threshold, syncAgg.SyncCommitteeBits.Count())
@@ -387,11 +343,6 @@ func checkSyncParticipation(conns []*grpc.ClientConn) error {
 		if err != nil {
 			return err
 		}
-		// Skip blocks with zero sync bits - these are typically empty/anomalous blocks
-		// where the proposer didn't receive sync committee contributions in time.
-		if syncAgg.SyncCommitteeBits.Count() == 0 {
-			continue
-		}
 		threshold := uint64(float64(syncAgg.SyncCommitteeBits.Len()) * expectedSyncParticipation)
 		if syncAgg.SyncCommitteeBits.Count() < threshold {
 			return errors.Errorf("In block of slot %d ,the aggregate bitvector with length of %d only got a count of %d", b.Block().Slot(), threshold, syncAgg.SyncCommitteeBits.Count())

testing/endtoend/minimal_builder_e2e_test.go

@@ -9,11 +9,11 @@ import (
 )
 
 func TestEndToEnd_MinimalConfig_WithBuilder(t *testing.T) {
-	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder(), types.WithBlobTxCount(2))
+	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder())
 	r.run()
 }
 
 func TestEndToEnd_MinimalConfig_WithBuilder_ValidatorRESTApi(t *testing.T) {
-	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder(), types.WithValidatorRESTApi(), types.WithBlobTxCount(2))
+	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder(), types.WithValidatorRESTApi())
 	r.run()
 }

testing/endtoend/types/types.go

@@ -68,14 +68,6 @@ func WithLargeBlobs() E2EConfigOpt {
 	}
 }
 
-// WithBlobTxCount sets the number of blob transactions sent per slot.
-// Default is 5 when not specified.
-func WithBlobTxCount(n int) E2EConfigOpt {
-	return func(cfg *E2EConfig) {
-		cfg.BlobTxCount = n
-	}
-}
-
 func WithSSZOnly() E2EConfigOpt {
 	return func(cfg *E2EConfig) {
 		if err := os.Setenv(params.EnvNameOverrideAccept, api.OctetStreamMediaType); err != nil {
@@ -116,7 +108,6 @@ type E2EConfig struct {
 	UseBeaconRestApi        bool
 	UseBuilder              bool
 	UseLargeBlobs           bool // Use large blob transactions (6 blobs per tx) for BPO testing
-	BlobTxCount             int  // Number of blob transactions per slot (0 means default of 5)
 	EpochsToRun             uint64
 	ExitEpoch               primitives.Epoch // Custom epoch for voluntary exit submission (0 means use default)
 	Seed                    int64

testing/spectest/README.md

@@ -21,14 +21,10 @@ There are tests for mainnet and minimal config, so for each config we will add a
 
 ## Running nightly spectests
 
-Since [PR 15312](https://github.com/OffchainLabs/prysm/pull/15312), Prysm has support to download "nightly" spectests from github via a starlark rule configuration by environment variable.
-Set `--repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly` or `--repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly-<run_id>` when running spectest to download the "nightly" spectests.
-Note: A GITHUB_TOKEN environment variable is required to be set. The github token does not need to be associated with your main account; it can be from a "burner account". And the token does not need to be a fine-grained token; it can be a classic token.
+Since [PR 15312](https://github.com/OffchainLabs/prysm/pull/15312), Prysm has support to download "nightly" spectests from github via a starlark rule configuration by environment variable. 
+Set `--repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly` when running spectest to download the "nightly" spectests. 
+Note: A GITHUB_TOKEN environment variable is required to be set. The github token must be a [fine grained token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-fine-grained-personal-access-token).
 
 ```
 bazel test //... --test_tag_filters=spectest --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly
 ```
-
-```
-bazel test //... --test_tag_filters=spectest --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly-21422848633
-```

tools/download_spectests.bzl

@@ -1,6 +1,5 @@
 # bazel build @consensus_spec_tests//:test_data
 # bazel build @consensus_spec_tests//:test_data --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly
-# bazel build @consensus_spec_tests//:test_data --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly-<run_id>
 
 def _get_redirected_url(repository_ctx, url, headers):
     if not repository_ctx.which("curl"):
@@ -25,7 +24,7 @@ def _impl(repository_ctx):
     version = repository_ctx.getenv("CONSENSUS_SPEC_TESTS_VERSION") or repository_ctx.attr.version
     token = repository_ctx.getenv("GITHUB_TOKEN") or ""
 
-    if version == "nightly" or version.startswith("nightly-"):
+    if version == "nightly":
         print("Downloading nightly tests")
         if not token:
             fail("Error GITHUB_TOKEN is not set")
@@ -35,22 +34,16 @@ def _impl(repository_ctx):
             "Accept": "application/vnd.github+json",
         }
 
-        if version.startswith("nightly-"):
-            run_id = version.split("nightly-", 1)[1]
-            if not run_id:
-                fail("Error invalid run id")
-        else:
-            repository_ctx.download(
-                "https://api.github.com/repos/%s/actions/workflows/%s/runs?branch=%s&status=success&per_page=1"
-                    % (repository_ctx.attr.repo, repository_ctx.attr.workflow, repository_ctx.attr.branch),
-                headers = headers,
-                output = "runs.json"
-            )
+        repository_ctx.download(
+            "https://api.github.com/repos/%s/actions/workflows/%s/runs?branch=%s&status=success&per_page=1"
+                % (repository_ctx.attr.repo, repository_ctx.attr.workflow, repository_ctx.attr.branch),
+            headers = headers,
+            output = "runs.json"
+        )
 
-            run_id = json.decode(repository_ctx.read("runs.json"))["workflow_runs"][0]["id"]
-            repository_ctx.delete("runs.json")
+        run_id = json.decode(repository_ctx.read("runs.json"))["workflow_runs"][0]["id"]
+        repository_ctx.delete("runs.json")
 
-        print("Run id:", run_id)
         repository_ctx.download(
             "https://api.github.com/repos/%s/actions/runs/%s/artifacts"
                 % (repository_ctx.attr.repo, run_id),
@@ -115,8 +108,8 @@ consensus_spec_tests = repository_rule(
         "version": attr.string(mandatory = True),
         "flavors": attr.string_dict(mandatory = True),
         "repo": attr.string(default = "ethereum/consensus-specs"),
-        "workflow": attr.string(default = "nightly-reftests.yml"),
-        "branch": attr.string(default = "master"),
+        "workflow": attr.string(default = "generate_vectors.yml"),
+        "branch": attr.string(default = "dev"),
         "release_url_template": attr.string(default = "https://github.com/ethereum/consensus-specs/releases/download/%s"),
     },
 )

validator/client/beacon-api/BUILD.bazel

@@ -51,6 +51,7 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//encoding/ssz:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/engine/v1:go_default_library",

validator/client/beacon-api/get_beacon_block.go

@@ -55,114 +55,153 @@ func (c *beaconApiValidatorClient) beaconBlock(ctx context.Context, slot primiti
 	}
 }
 
+// sszBlockCodec defines SSZ unmarshalers for a fork's block and blinded block types.
+type sszBlockCodec struct {
+	unmarshalBlock   func([]byte) (*ethpb.GenericBeaconBlock, error)
+	unmarshalBlinded func([]byte) (*ethpb.GenericBeaconBlock, error) // nil for Phase0/Altair
+}
+
+type sszCodecEntry struct {
+	minVersion int
+	codec      sszBlockCodec
+}
+
+// sszCodecs is ordered descending by version so that unknown future versions
+// fall through to the latest known fork (matching the original if-cascade).
+var sszCodecs = []sszCodecEntry{
+	{
+		minVersion: version.Fulu,
+		codec: sszBlockCodec{
+			unmarshalBlock: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				block := &ethpb.BeaconBlockContentsFulu{}
+				if err := block.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Fulu{Fulu: block}}, nil
+			},
+			unmarshalBlinded: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				blindedBlock := &ethpb.BlindedBeaconBlockFulu{}
+				if err := blindedBlock.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedFulu{BlindedFulu: blindedBlock}, IsBlinded: true}, nil
+			},
+		},
+	},
+	{
+		minVersion: version.Electra,
+		codec: sszBlockCodec{
+			unmarshalBlock: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				block := &ethpb.BeaconBlockContentsElectra{}
+				if err := block.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Electra{Electra: block}}, nil
+			},
+			unmarshalBlinded: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				blindedBlock := &ethpb.BlindedBeaconBlockElectra{}
+				if err := blindedBlock.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedElectra{BlindedElectra: blindedBlock}, IsBlinded: true}, nil
+			},
+		},
+	},
+	{
+		minVersion: version.Deneb,
+		codec: sszBlockCodec{
+			unmarshalBlock: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				block := &ethpb.BeaconBlockContentsDeneb{}
+				if err := block.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Deneb{Deneb: block}}, nil
+			},
+			unmarshalBlinded: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				blindedBlock := &ethpb.BlindedBeaconBlockDeneb{}
+				if err := blindedBlock.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedDeneb{BlindedDeneb: blindedBlock}, IsBlinded: true}, nil
+			},
+		},
+	},
+	{
+		minVersion: version.Capella,
+		codec: sszBlockCodec{
+			unmarshalBlock: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				block := &ethpb.BeaconBlockCapella{}
+				if err := block.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Capella{Capella: block}}, nil
+			},
+			unmarshalBlinded: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				blindedBlock := &ethpb.BlindedBeaconBlockCapella{}
+				if err := blindedBlock.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedCapella{BlindedCapella: blindedBlock}, IsBlinded: true}, nil
+			},
+		},
+	},
+	{
+		minVersion: version.Bellatrix,
+		codec: sszBlockCodec{
+			unmarshalBlock: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				block := &ethpb.BeaconBlockBellatrix{}
+				if err := block.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Bellatrix{Bellatrix: block}}, nil
+			},
+			unmarshalBlinded: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				blindedBlock := &ethpb.BlindedBeaconBlockBellatrix{}
+				if err := blindedBlock.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedBellatrix{BlindedBellatrix: blindedBlock}, IsBlinded: true}, nil
+			},
+		},
+	},
+	{
+		minVersion: version.Altair,
+		codec: sszBlockCodec{
+			unmarshalBlock: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				block := &ethpb.BeaconBlockAltair{}
+				if err := block.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Altair{Altair: block}}, nil
+			},
+		},
+	},
+	{
+		minVersion: version.Phase0,
+		codec: sszBlockCodec{
+			unmarshalBlock: func(data []byte) (*ethpb.GenericBeaconBlock, error) {
+				block := &ethpb.BeaconBlock{}
+				if err := block.UnmarshalSSZ(data); err != nil {
+					return nil, err
+				}
+				return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Phase0{Phase0: block}}, nil
+			},
+		},
+	},
+}
+
 func processBlockSSZResponse(ver int, data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if ver >= version.Fulu {
-		return processBlockSSZResponseFulu(data, isBlinded)
-	}
-	if ver >= version.Electra {
-		return processBlockSSZResponseElectra(data, isBlinded)
-	}
-	if ver >= version.Deneb {
-		return processBlockSSZResponseDeneb(data, isBlinded)
-	}
-	if ver >= version.Capella {
-		return processBlockSSZResponseCapella(data, isBlinded)
-	}
-	if ver >= version.Bellatrix {
-		return processBlockSSZResponseBellatrix(data, isBlinded)
-	}
-	if ver >= version.Altair {
-		block := &ethpb.BeaconBlockAltair{}
-		if err := block.UnmarshalSSZ(data); err != nil {
-			return nil, err
+	for _, entry := range sszCodecs {
+		if ver >= entry.minVersion {
+			if isBlinded && entry.codec.unmarshalBlinded != nil {
+				return entry.codec.unmarshalBlinded(data)
+			}
+			return entry.codec.unmarshalBlock(data)
 		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Altair{Altair: block}}, nil
-	}
-	if ver >= version.Phase0 {
-		block := &ethpb.BeaconBlock{}
-		if err := block.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Phase0{Phase0: block}}, nil
 	}
 	return nil, fmt.Errorf("unsupported block version %s", version.String(ver))
 }
 
-func processBlockSSZResponseFulu(data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		blindedBlock := &ethpb.BlindedBeaconBlockFulu{}
-		if err := blindedBlock.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedFulu{BlindedFulu: blindedBlock}, IsBlinded: true}, nil
-	}
-	block := &ethpb.BeaconBlockContentsFulu{}
-	if err := block.UnmarshalSSZ(data); err != nil {
-		return nil, err
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Fulu{Fulu: block}}, nil
-}
-
-func processBlockSSZResponseElectra(data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		blindedBlock := &ethpb.BlindedBeaconBlockElectra{}
-		if err := blindedBlock.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedElectra{BlindedElectra: blindedBlock}, IsBlinded: true}, nil
-	}
-	block := &ethpb.BeaconBlockContentsElectra{}
-	if err := block.UnmarshalSSZ(data); err != nil {
-		return nil, err
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Electra{Electra: block}}, nil
-}
-
-func processBlockSSZResponseDeneb(data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		blindedBlock := &ethpb.BlindedBeaconBlockDeneb{}
-		if err := blindedBlock.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedDeneb{BlindedDeneb: blindedBlock}, IsBlinded: true}, nil
-	}
-	block := &ethpb.BeaconBlockContentsDeneb{}
-	if err := block.UnmarshalSSZ(data); err != nil {
-		return nil, err
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Deneb{Deneb: block}}, nil
-}
-
-func processBlockSSZResponseCapella(data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		blindedBlock := &ethpb.BlindedBeaconBlockCapella{}
-		if err := blindedBlock.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedCapella{BlindedCapella: blindedBlock}, IsBlinded: true}, nil
-	}
-	block := &ethpb.BeaconBlockCapella{}
-	if err := block.UnmarshalSSZ(data); err != nil {
-		return nil, err
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Capella{Capella: block}}, nil
-}
-
-func processBlockSSZResponseBellatrix(data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		blindedBlock := &ethpb.BlindedBeaconBlockBellatrix{}
-		if err := blindedBlock.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedBellatrix{BlindedBellatrix: blindedBlock}, IsBlinded: true}, nil
-	}
-	block := &ethpb.BeaconBlockBellatrix{}
-	if err := block.UnmarshalSSZ(data); err != nil {
-		return nil, err
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Bellatrix{Bellatrix: block}}, nil
-}
-
 func convertBlockToGeneric(decoder *json.Decoder, dest ethpb.GenericConverter, version string, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
 	typeName := version
 	if isBlinded {
@@ -180,69 +219,52 @@ func convertBlockToGeneric(decoder *json.Decoder, dest ethpb.GenericConverter, v
 	return genericBlock, nil
 }
 
+// jsonBlockTypes defines factory functions for creating block and blinded block structs for JSON decoding.
+type jsonBlockTypes struct {
+	newBlock   func() ethpb.GenericConverter
+	newBlinded func() ethpb.GenericConverter // nil for Phase0/Altair
+}
+
+var jsonBlockFactories = map[string]jsonBlockTypes{
+	version.String(version.Phase0): {
+		newBlock: func() ethpb.GenericConverter { return &structs.BeaconBlock{} },
+	},
+	version.String(version.Altair): {
+		newBlock: func() ethpb.GenericConverter { return &structs.BeaconBlockAltair{} },
+	},
+	version.String(version.Bellatrix): {
+		newBlock:   func() ethpb.GenericConverter { return &structs.BeaconBlockBellatrix{} },
+		newBlinded: func() ethpb.GenericConverter { return &structs.BlindedBeaconBlockBellatrix{} },
+	},
+	version.String(version.Capella): {
+		newBlock:   func() ethpb.GenericConverter { return &structs.BeaconBlockCapella{} },
+		newBlinded: func() ethpb.GenericConverter { return &structs.BlindedBeaconBlockCapella{} },
+	},
+	version.String(version.Deneb): {
+		newBlock:   func() ethpb.GenericConverter { return &structs.BeaconBlockContentsDeneb{} },
+		newBlinded: func() ethpb.GenericConverter { return &structs.BlindedBeaconBlockDeneb{} },
+	},
+	version.String(version.Electra): {
+		newBlock:   func() ethpb.GenericConverter { return &structs.BeaconBlockContentsElectra{} },
+		newBlinded: func() ethpb.GenericConverter { return &structs.BlindedBeaconBlockElectra{} },
+	},
+	version.String(version.Fulu): {
+		newBlock:   func() ethpb.GenericConverter { return &structs.BeaconBlockContentsFulu{} },
+		newBlinded: func() ethpb.GenericConverter { return &structs.BlindedBeaconBlockFulu{} },
+	},
+}
+
 func processBlockJSONResponse(ver string, isBlinded bool, decoder *json.Decoder) (*ethpb.GenericBeaconBlock, error) {
 	if decoder == nil {
 		return nil, errors.New("no produce block json decoder found")
 	}
 
-	switch ver {
-	case version.String(version.Phase0):
-		return convertBlockToGeneric(decoder, &structs.BeaconBlock{}, version.String(version.Phase0), false)
-
-	case version.String(version.Altair):
-		return convertBlockToGeneric(decoder, &structs.BeaconBlockAltair{}, "altair", false)
-
-	case version.String(version.Bellatrix):
-		return processBellatrixBlock(decoder, isBlinded)
-
-	case version.String(version.Capella):
-		return processCapellaBlock(decoder, isBlinded)
-
-	case version.String(version.Deneb):
-		return processDenebBlock(decoder, isBlinded)
-
-	case version.String(version.Electra):
-		return processElectraBlock(decoder, isBlinded)
-
-	case version.String(version.Fulu):
-		return processFuluBlock(decoder, isBlinded)
-
-	default:
+	factory, ok := jsonBlockFactories[ver]
+	if !ok {
 		return nil, errors.Errorf("unsupported consensus version `%s`", ver)
 	}
-}
-
-func processBellatrixBlock(decoder *json.Decoder, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		return convertBlockToGeneric(decoder, &structs.BlindedBeaconBlockBellatrix{}, "bellatrix", true)
+	if isBlinded && factory.newBlinded != nil {
+		return convertBlockToGeneric(decoder, factory.newBlinded(), ver, true)
 	}
-	return convertBlockToGeneric(decoder, &structs.BeaconBlockBellatrix{}, "bellatrix", false)
-}
-
-func processCapellaBlock(decoder *json.Decoder, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		return convertBlockToGeneric(decoder, &structs.BlindedBeaconBlockCapella{}, "capella", true)
-	}
-	return convertBlockToGeneric(decoder, &structs.BeaconBlockCapella{}, "capella", false)
-}
-
-func processDenebBlock(decoder *json.Decoder, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		return convertBlockToGeneric(decoder, &structs.BlindedBeaconBlockDeneb{}, "deneb", true)
-	}
-	return convertBlockToGeneric(decoder, &structs.BeaconBlockContentsDeneb{}, "deneb", false)
-}
-
-func processElectraBlock(decoder *json.Decoder, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		return convertBlockToGeneric(decoder, &structs.BlindedBeaconBlockElectra{}, "electra", true)
-	}
-	return convertBlockToGeneric(decoder, &structs.BeaconBlockContentsElectra{}, "electra", false)
-}
-
-func processFuluBlock(decoder *json.Decoder, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		return convertBlockToGeneric(decoder, &structs.BlindedBeaconBlockFulu{}, "fulu", true)
-	}
-	return convertBlockToGeneric(decoder, &structs.BeaconBlockContentsFulu{}, "fulu", false)
+	return convertBlockToGeneric(decoder, factory.newBlock(), ver, false)
 }

validator/client/beacon-api/propose_beacon_block.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
+	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
 	"github.com/OffchainLabs/prysm/v7/network/httputil"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
@@ -21,34 +22,128 @@ type blockProcessingResult struct {
 	marshalJSON func() ([]byte, error)
 }
 
+type sszMarshaler interface {
+	MarshalSSZ() ([]byte, error)
+}
+
+func buildBlockResult(
+	versionName string,
+	blinded bool,
+	sszObj sszMarshaler,
+	rootObj ssz.Hashable,
+	jsonFn func() ([]byte, error),
+) (*blockProcessingResult, error) {
+	beaconBlockRoot, err := rootObj.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to compute block root for %s beacon block", versionName)
+	}
+
+	ssz, err := sszObj.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to serialize %s beacon block", versionName)
+	}
+
+	return &blockProcessingResult{
+		consensusVersion: versionName,
+		blinded:          blinded,
+		beaconBlockRoot:  beaconBlockRoot,
+		marshalledSSZ:    ssz,
+		marshalJSON:      jsonFn,
+	}, nil
+}
+
 func (c *beaconApiValidatorClient) proposeBeaconBlock(ctx context.Context, in *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
 	var res *blockProcessingResult
 	var err error
 	switch blockType := in.Block.(type) {
 	case *ethpb.GenericSignedBeaconBlock_Phase0:
-		res, err = handlePhase0Block(blockType)
+		res, err = buildBlockResult("phase0", false, blockType.Phase0, blockType.Phase0.Block, func() ([]byte, error) {
+			return json.Marshal(structs.SignedBeaconBlockPhase0FromConsensus(blockType.Phase0))
+		})
 	case *ethpb.GenericSignedBeaconBlock_Altair:
-		res, err = handleAltairBlock(blockType)
+		res, err = buildBlockResult("altair", false, blockType.Altair, blockType.Altair.Block, func() ([]byte, error) {
+			return json.Marshal(structs.SignedBeaconBlockAltairFromConsensus(blockType.Altair))
+		})
 	case *ethpb.GenericSignedBeaconBlock_Bellatrix:
-		res, err = handleBellatrixBlock(blockType)
+		res, err = buildBlockResult("bellatrix", false, blockType.Bellatrix, blockType.Bellatrix.Block, func() ([]byte, error) {
+			signedBlock, err := structs.SignedBeaconBlockBellatrixFromConsensus(blockType.Bellatrix)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to convert bellatrix beacon block")
+			}
+			return json.Marshal(signedBlock)
+		})
 	case *ethpb.GenericSignedBeaconBlock_BlindedBellatrix:
-		res, err = handleBlindedBellatrixBlock(blockType)
+		res, err = buildBlockResult("bellatrix", true, blockType.BlindedBellatrix, blockType.BlindedBellatrix.Block, func() ([]byte, error) {
+			signedBlock, err := structs.SignedBlindedBeaconBlockBellatrixFromConsensus(blockType.BlindedBellatrix)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to convert blinded bellatrix beacon block")
+			}
+			return json.Marshal(signedBlock)
+		})
 	case *ethpb.GenericSignedBeaconBlock_Capella:
-		res, err = handleCapellaBlock(blockType)
+		res, err = buildBlockResult("capella", false, blockType.Capella, blockType.Capella.Block, func() ([]byte, error) {
+			signedBlock, err := structs.SignedBeaconBlockCapellaFromConsensus(blockType.Capella)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to convert capella beacon block")
+			}
+			return json.Marshal(signedBlock)
+		})
 	case *ethpb.GenericSignedBeaconBlock_BlindedCapella:
-		res, err = handleBlindedCapellaBlock(blockType)
+		res, err = buildBlockResult("capella", true, blockType.BlindedCapella, blockType.BlindedCapella.Block, func() ([]byte, error) {
+			signedBlock, err := structs.SignedBlindedBeaconBlockCapellaFromConsensus(blockType.BlindedCapella)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to convert blinded capella beacon block")
+			}
+			return json.Marshal(signedBlock)
+		})
 	case *ethpb.GenericSignedBeaconBlock_Deneb:
-		res, err = handleDenebBlockContents(blockType)
+		res, err = buildBlockResult("deneb", false, blockType.Deneb, blockType.Deneb.Block, func() ([]byte, error) {
+			signedBlock, err := structs.SignedBeaconBlockContentsDenebFromConsensus(blockType.Deneb)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to convert deneb beacon block contents")
+			}
+			return json.Marshal(signedBlock)
+		})
 	case *ethpb.GenericSignedBeaconBlock_BlindedDeneb:
-		res, err = handleBlindedDenebBlock(blockType)
+		res, err = buildBlockResult("deneb", true, blockType.BlindedDeneb, blockType.BlindedDeneb, func() ([]byte, error) {
+			signedBlock, err := structs.SignedBlindedBeaconBlockDenebFromConsensus(blockType.BlindedDeneb)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to convert deneb blinded beacon block")
+			}
+			return json.Marshal(signedBlock)
+		})
 	case *ethpb.GenericSignedBeaconBlock_Electra:
-		res, err = handleElectraBlockContents(blockType)
+		res, err = buildBlockResult("electra", false, blockType.Electra, blockType.Electra.Block, func() ([]byte, error) {
+			signedBlock, err := structs.SignedBeaconBlockContentsElectraFromConsensus(blockType.Electra)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to convert electra beacon block contents")
+			}
+			return json.Marshal(signedBlock)
+		})
 	case *ethpb.GenericSignedBeaconBlock_BlindedElectra:
-		res, err = handleBlindedElectraBlock(blockType)
+		res, err = buildBlockResult("electra", true, blockType.BlindedElectra, blockType.BlindedElectra, func() ([]byte, error) {
+			signedBlock, err := structs.SignedBlindedBeaconBlockElectraFromConsensus(blockType.BlindedElectra)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to convert electra blinded beacon block")
+			}
+			return json.Marshal(signedBlock)
+		})
 	case *ethpb.GenericSignedBeaconBlock_Fulu:
-		res, err = handleFuluBlockContents(blockType)
+		res, err = buildBlockResult("fulu", false, blockType.Fulu, blockType.Fulu.Block, func() ([]byte, error) {
+			signedBlock, err := structs.SignedBeaconBlockContentsFuluFromConsensus(blockType.Fulu)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to convert fulu beacon block contents")
+			}
+			return json.Marshal(signedBlock)
+		})
 	case *ethpb.GenericSignedBeaconBlock_BlindedFulu:
-		res, err = handleBlindedFuluBlock(blockType)
+		res, err = buildBlockResult("fulu", true, blockType.BlindedFulu, blockType.BlindedFulu, func() ([]byte, error) {
+			signedBlock, err := structs.SignedBlindedBeaconBlockFuluFromConsensus(blockType.BlindedFulu)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to convert fulu blinded beacon block")
+			}
+			return json.Marshal(signedBlock)
+		})
 	default:
 		return nil, errors.Errorf("unsupported block type %T", in.Block)
 	}
@@ -116,357 +211,3 @@ func (c *beaconApiValidatorClient) proposeBeaconBlock(ctx context.Context, in *e
 
 	return &ethpb.ProposeResponse{BlockRoot: res.beaconBlockRoot[:]}, nil
 }
-
-func handlePhase0Block(block *ethpb.GenericSignedBeaconBlock_Phase0) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "phase0"
-	res.blinded = false
-
-	beaconBlockRoot, err := block.Phase0.Block.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for phase0 beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.Phase0.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize block for phase0 beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock := structs.SignedBeaconBlockPhase0FromConsensus(block.Phase0)
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}
-
-func handleAltairBlock(block *ethpb.GenericSignedBeaconBlock_Altair) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "altair"
-	res.blinded = false
-
-	beaconBlockRoot, err := block.Altair.Block.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for altair beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.Altair.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize block for altair beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock := structs.SignedBeaconBlockAltairFromConsensus(block.Altair)
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}
-
-func handleBellatrixBlock(block *ethpb.GenericSignedBeaconBlock_Bellatrix) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "bellatrix"
-	res.blinded = false
-
-	beaconBlockRoot, err := block.Bellatrix.Block.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for bellatrix beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.Bellatrix.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize block for bellatrix beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock, err := structs.SignedBeaconBlockBellatrixFromConsensus(block.Bellatrix)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert bellatrix beacon block")
-		}
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}
-
-func handleBlindedBellatrixBlock(block *ethpb.GenericSignedBeaconBlock_BlindedBellatrix) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "bellatrix"
-	res.blinded = true
-
-	beaconBlockRoot, err := block.BlindedBellatrix.Block.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for bellatrix beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.BlindedBellatrix.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize block for bellatrix beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock, err := structs.SignedBlindedBeaconBlockBellatrixFromConsensus(block.BlindedBellatrix)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert blinded bellatrix beacon block")
-		}
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}
-
-func handleCapellaBlock(block *ethpb.GenericSignedBeaconBlock_Capella) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "capella"
-	res.blinded = false
-
-	beaconBlockRoot, err := block.Capella.Block.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for capella beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.Capella.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize capella beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock, err := structs.SignedBeaconBlockCapellaFromConsensus(block.Capella)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert capella beacon block")
-		}
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}
-
-func handleBlindedCapellaBlock(block *ethpb.GenericSignedBeaconBlock_BlindedCapella) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "capella"
-	res.blinded = true
-
-	beaconBlockRoot, err := block.BlindedCapella.Block.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for blinded capella beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.BlindedCapella.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize blinded capella beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock, err := structs.SignedBlindedBeaconBlockCapellaFromConsensus(block.BlindedCapella)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert blinded capella beacon block")
-		}
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}
-
-func handleDenebBlockContents(block *ethpb.GenericSignedBeaconBlock_Deneb) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "deneb"
-	res.blinded = false
-
-	beaconBlockRoot, err := block.Deneb.Block.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for deneb beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.Deneb.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize deneb beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock, err := structs.SignedBeaconBlockContentsDenebFromConsensus(block.Deneb)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert deneb beacon block contents")
-		}
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}
-
-func handleBlindedDenebBlock(block *ethpb.GenericSignedBeaconBlock_BlindedDeneb) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "deneb"
-	res.blinded = true
-
-	beaconBlockRoot, err := block.BlindedDeneb.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for deneb blinded beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.BlindedDeneb.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize blinded deneb  beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock, err := structs.SignedBlindedBeaconBlockDenebFromConsensus(block.BlindedDeneb)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert deneb blinded beacon block")
-		}
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}
-
-func handleElectraBlockContents(block *ethpb.GenericSignedBeaconBlock_Electra) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "electra"
-	res.blinded = false
-
-	beaconBlockRoot, err := block.Electra.Block.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for electra beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.Electra.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize electra beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock, err := structs.SignedBeaconBlockContentsElectraFromConsensus(block.Electra)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert electra beacon block contents")
-		}
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}
-
-func handleBlindedElectraBlock(block *ethpb.GenericSignedBeaconBlock_BlindedElectra) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "electra"
-	res.blinded = true
-
-	beaconBlockRoot, err := block.BlindedElectra.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for electra blinded beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.BlindedElectra.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize blinded electra beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock, err := structs.SignedBlindedBeaconBlockElectraFromConsensus(block.BlindedElectra)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert electra blinded beacon block")
-		}
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}
-
-func handleFuluBlockContents(block *ethpb.GenericSignedBeaconBlock_Fulu) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "fulu"
-	res.blinded = false
-
-	beaconBlockRoot, err := block.Fulu.Block.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for fulu beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.Fulu.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize fulu beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock, err := structs.SignedBeaconBlockContentsFuluFromConsensus(block.Fulu)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert fulu beacon block contents")
-		}
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}
-
-func handleBlindedFuluBlock(block *ethpb.GenericSignedBeaconBlock_BlindedFulu) (*blockProcessingResult, error) {
-	var res blockProcessingResult
-	res.consensusVersion = "fulu"
-	res.blinded = true
-
-	beaconBlockRoot, err := block.BlindedFulu.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to compute block root for fulu blinded beacon block")
-	}
-	res.beaconBlockRoot = beaconBlockRoot
-
-	// Marshal SSZ
-	ssz, err := block.BlindedFulu.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to serialize blinded fulu beacon block")
-	}
-	res.marshalledSSZ = ssz
-
-	// Set up JSON marshalling function for fallback
-	res.marshalJSON = func() ([]byte, error) {
-		signedBlock, err := structs.SignedBlindedBeaconBlockFuluFromConsensus(block.BlindedFulu)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert fulu blinded beacon block")
-		}
-		return json.Marshal(signedBlock)
-	}
-
-	return &res, nil
-}