deduplicating rest propose block (#15147)

* deduplicating rest propose block

* gaz

* linting

* gaz and linting

* remove unneeded import"
"

* gofmt

validator/client/beacon-api/beacon_block_json_helpers.go

@@ -19,23 +19,6 @@ func jsonifyTransactions(transactions [][]byte) []string {
 	return jsonTransactions
 }
 
-func jsonifyBlsToExecutionChanges(blsToExecutionChanges []*ethpb.SignedBLSToExecutionChange) []*structs.SignedBLSToExecutionChange {
-	jsonBlsToExecutionChanges := make([]*structs.SignedBLSToExecutionChange, len(blsToExecutionChanges))
-	for index, signedBlsToExecutionChange := range blsToExecutionChanges {
-		blsToExecutionChangeJson := &structs.BLSToExecutionChange{
-			ValidatorIndex:     apiutil.Uint64ToString(signedBlsToExecutionChange.Message.ValidatorIndex),
-			FromBLSPubkey:      hexutil.Encode(signedBlsToExecutionChange.Message.FromBlsPubkey),
-			ToExecutionAddress: hexutil.Encode(signedBlsToExecutionChange.Message.ToExecutionAddress),
-		}
-		signedJson := &structs.SignedBLSToExecutionChange{
-			Message:   blsToExecutionChangeJson,
-			Signature: hexutil.Encode(signedBlsToExecutionChange.Signature),
-		}
-		jsonBlsToExecutionChanges[index] = signedJson
-	}
-	return jsonBlsToExecutionChanges
-}
-
 func jsonifyEth1Data(eth1Data *ethpb.Eth1Data) *structs.Eth1Data {
 	return &structs.Eth1Data{
 		BlockHash:    hexutil.Encode(eth1Data.BlockHash),
@@ -60,52 +43,6 @@ func jsonifySingleAttestations(attestations []*ethpb.SingleAttestation) []*struc
 	return jsonAttestations
 }
 
-func jsonifyAttesterSlashings(attesterSlashings []*ethpb.AttesterSlashing) []*structs.AttesterSlashing {
-	jsonAttesterSlashings := make([]*structs.AttesterSlashing, len(attesterSlashings))
-	for index, attesterSlashing := range attesterSlashings {
-		jsonAttesterSlashing := &structs.AttesterSlashing{
-			Attestation1: jsonifyIndexedAttestation(attesterSlashing.Attestation_1),
-			Attestation2: jsonifyIndexedAttestation(attesterSlashing.Attestation_2),
-		}
-		jsonAttesterSlashings[index] = jsonAttesterSlashing
-	}
-	return jsonAttesterSlashings
-}
-
-func jsonifyDeposits(deposits []*ethpb.Deposit) []*structs.Deposit {
-	jsonDeposits := make([]*structs.Deposit, len(deposits))
-	for depositIndex, deposit := range deposits {
-		proofs := make([]string, len(deposit.Proof))
-		for proofIndex, proof := range deposit.Proof {
-			proofs[proofIndex] = hexutil.Encode(proof)
-		}
-
-		jsonDeposit := &structs.Deposit{
-			Data: &structs.DepositData{
-				Amount:                apiutil.Uint64ToString(deposit.Data.Amount),
-				Pubkey:                hexutil.Encode(deposit.Data.PublicKey),
-				Signature:             hexutil.Encode(deposit.Data.Signature),
-				WithdrawalCredentials: hexutil.Encode(deposit.Data.WithdrawalCredentials),
-			},
-			Proof: proofs,
-		}
-		jsonDeposits[depositIndex] = jsonDeposit
-	}
-	return jsonDeposits
-}
-
-func jsonifyProposerSlashings(proposerSlashings []*ethpb.ProposerSlashing) []*structs.ProposerSlashing {
-	jsonProposerSlashings := make([]*structs.ProposerSlashing, len(proposerSlashings))
-	for index, proposerSlashing := range proposerSlashings {
-		jsonProposerSlashing := &structs.ProposerSlashing{
-			SignedHeader1: jsonifySignedBeaconBlockHeader(proposerSlashing.Header_1),
-			SignedHeader2: jsonifySignedBeaconBlockHeader(proposerSlashing.Header_2),
-		}
-		jsonProposerSlashings[index] = jsonProposerSlashing
-	}
-	return jsonProposerSlashings
-}
-
 // JsonifySignedVoluntaryExits converts an array of voluntary exit structs to a JSON hex string compatible format.
 func JsonifySignedVoluntaryExits(voluntaryExits []*ethpb.SignedVoluntaryExit) []*structs.SignedVoluntaryExit {
 	jsonSignedVoluntaryExits := make([]*structs.SignedVoluntaryExit, len(voluntaryExits))

validator/client/beacon-api/beacon_block_json_helpers_test.go

@@ -162,316 +162,6 @@ func TestBeaconBlockJsonHelpers_JsonifyAttestations(t *testing.T) {
 	assert.DeepEqual(t, expectedResult, result)
 }
 
-func TestBeaconBlockJsonHelpers_JsonifyAttesterSlashings(t *testing.T) {
-	input := []*ethpb.AttesterSlashing{
-		{
-			Attestation_1: &ethpb.IndexedAttestation{
-				AttestingIndices: []uint64{1, 2},
-				Data: &ethpb.AttestationData{
-					Slot:            3,
-					CommitteeIndex:  4,
-					BeaconBlockRoot: []byte{5},
-					Source: &ethpb.Checkpoint{
-						Epoch: 6,
-						Root:  []byte{7},
-					},
-					Target: &ethpb.Checkpoint{
-						Epoch: 8,
-						Root:  []byte{9},
-					},
-				},
-				Signature: []byte{10},
-			},
-			Attestation_2: &ethpb.IndexedAttestation{
-				AttestingIndices: []uint64{11, 12},
-				Data: &ethpb.AttestationData{
-					Slot:            13,
-					CommitteeIndex:  14,
-					BeaconBlockRoot: []byte{15},
-					Source: &ethpb.Checkpoint{
-						Epoch: 16,
-						Root:  []byte{17},
-					},
-					Target: &ethpb.Checkpoint{
-						Epoch: 18,
-						Root:  []byte{19},
-					},
-				},
-				Signature: []byte{20},
-			},
-		},
-		{
-			Attestation_1: &ethpb.IndexedAttestation{
-				AttestingIndices: []uint64{21, 22},
-				Data: &ethpb.AttestationData{
-					Slot:            23,
-					CommitteeIndex:  24,
-					BeaconBlockRoot: []byte{25},
-					Source: &ethpb.Checkpoint{
-						Epoch: 26,
-						Root:  []byte{27},
-					},
-					Target: &ethpb.Checkpoint{
-						Epoch: 28,
-						Root:  []byte{29},
-					},
-				},
-				Signature: []byte{30},
-			},
-			Attestation_2: &ethpb.IndexedAttestation{
-				AttestingIndices: []uint64{31, 32},
-				Data: &ethpb.AttestationData{
-					Slot:            33,
-					CommitteeIndex:  34,
-					BeaconBlockRoot: []byte{35},
-					Source: &ethpb.Checkpoint{
-						Epoch: 36,
-						Root:  []byte{37},
-					},
-					Target: &ethpb.Checkpoint{
-						Epoch: 38,
-						Root:  []byte{39},
-					},
-				},
-				Signature: []byte{40},
-			},
-		},
-	}
-
-	expectedResult := []*structs.AttesterSlashing{
-		{
-			Attestation1: &structs.IndexedAttestation{
-				AttestingIndices: []string{"1", "2"},
-				Data: &structs.AttestationData{
-					Slot:            "3",
-					CommitteeIndex:  "4",
-					BeaconBlockRoot: hexutil.Encode([]byte{5}),
-					Source: &structs.Checkpoint{
-						Epoch: "6",
-						Root:  hexutil.Encode([]byte{7}),
-					},
-					Target: &structs.Checkpoint{
-						Epoch: "8",
-						Root:  hexutil.Encode([]byte{9}),
-					},
-				},
-				Signature: hexutil.Encode([]byte{10}),
-			},
-			Attestation2: &structs.IndexedAttestation{
-				AttestingIndices: []string{"11", "12"},
-				Data: &structs.AttestationData{
-					Slot:            "13",
-					CommitteeIndex:  "14",
-					BeaconBlockRoot: hexutil.Encode([]byte{15}),
-					Source: &structs.Checkpoint{
-						Epoch: "16",
-						Root:  hexutil.Encode([]byte{17}),
-					},
-					Target: &structs.Checkpoint{
-						Epoch: "18",
-						Root:  hexutil.Encode([]byte{19}),
-					},
-				},
-				Signature: hexutil.Encode([]byte{20}),
-			},
-		},
-		{
-			Attestation1: &structs.IndexedAttestation{
-				AttestingIndices: []string{"21", "22"},
-				Data: &structs.AttestationData{
-					Slot:            "23",
-					CommitteeIndex:  "24",
-					BeaconBlockRoot: hexutil.Encode([]byte{25}),
-					Source: &structs.Checkpoint{
-						Epoch: "26",
-						Root:  hexutil.Encode([]byte{27}),
-					},
-					Target: &structs.Checkpoint{
-						Epoch: "28",
-						Root:  hexutil.Encode([]byte{29}),
-					},
-				},
-				Signature: hexutil.Encode([]byte{30}),
-			},
-			Attestation2: &structs.IndexedAttestation{
-				AttestingIndices: []string{"31", "32"},
-				Data: &structs.AttestationData{
-					Slot:            "33",
-					CommitteeIndex:  "34",
-					BeaconBlockRoot: hexutil.Encode([]byte{35}),
-					Source: &structs.Checkpoint{
-						Epoch: "36",
-						Root:  hexutil.Encode([]byte{37}),
-					},
-					Target: &structs.Checkpoint{
-						Epoch: "38",
-						Root:  hexutil.Encode([]byte{39}),
-					},
-				},
-				Signature: hexutil.Encode([]byte{40}),
-			},
-		},
-	}
-
-	result := jsonifyAttesterSlashings(input)
-	assert.DeepEqual(t, expectedResult, result)
-}
-
-func TestBeaconBlockJsonHelpers_JsonifyDeposits(t *testing.T) {
-	input := []*ethpb.Deposit{
-		{
-			Proof: [][]byte{{1}, {2}},
-			Data: &ethpb.Deposit_Data{
-				PublicKey:             []byte{3},
-				WithdrawalCredentials: []byte{4},
-				Amount:                5,
-				Signature:             []byte{6},
-			},
-		},
-		{
-			Proof: [][]byte{
-				{7},
-				{8},
-			},
-			Data: &ethpb.Deposit_Data{
-				PublicKey:             []byte{9},
-				WithdrawalCredentials: []byte{10},
-				Amount:                11,
-				Signature:             []byte{12},
-			},
-		},
-	}
-
-	expectedResult := []*structs.Deposit{
-		{
-			Proof: []string{
-				hexutil.Encode([]byte{1}),
-				hexutil.Encode([]byte{2}),
-			},
-			Data: &structs.DepositData{
-				Pubkey:                hexutil.Encode([]byte{3}),
-				WithdrawalCredentials: hexutil.Encode([]byte{4}),
-				Amount:                "5",
-				Signature:             hexutil.Encode([]byte{6}),
-			},
-		},
-		{
-			Proof: []string{
-				hexutil.Encode([]byte{7}),
-				hexutil.Encode([]byte{8}),
-			},
-			Data: &structs.DepositData{
-				Pubkey:                hexutil.Encode([]byte{9}),
-				WithdrawalCredentials: hexutil.Encode([]byte{10}),
-				Amount:                "11",
-				Signature:             hexutil.Encode([]byte{12}),
-			},
-		},
-	}
-
-	result := jsonifyDeposits(input)
-	assert.DeepEqual(t, expectedResult, result)
-}
-
-func TestBeaconBlockJsonHelpers_JsonifyProposerSlashings(t *testing.T) {
-	input := []*ethpb.ProposerSlashing{
-		{
-			Header_1: &ethpb.SignedBeaconBlockHeader{
-				Header: &ethpb.BeaconBlockHeader{
-					Slot:          1,
-					ProposerIndex: 2,
-					ParentRoot:    []byte{3},
-					StateRoot:     []byte{4},
-					BodyRoot:      []byte{5},
-				},
-				Signature: []byte{6},
-			},
-			Header_2: &ethpb.SignedBeaconBlockHeader{
-				Header: &ethpb.BeaconBlockHeader{
-					Slot:          7,
-					ProposerIndex: 8,
-					ParentRoot:    []byte{9},
-					StateRoot:     []byte{10},
-					BodyRoot:      []byte{11},
-				},
-				Signature: []byte{12},
-			},
-		},
-		{
-			Header_1: &ethpb.SignedBeaconBlockHeader{
-				Header: &ethpb.BeaconBlockHeader{
-					Slot:          13,
-					ProposerIndex: 14,
-					ParentRoot:    []byte{15},
-					StateRoot:     []byte{16},
-					BodyRoot:      []byte{17},
-				},
-				Signature: []byte{18},
-			},
-			Header_2: &ethpb.SignedBeaconBlockHeader{
-				Header: &ethpb.BeaconBlockHeader{
-					Slot:          19,
-					ProposerIndex: 20,
-					ParentRoot:    []byte{21},
-					StateRoot:     []byte{22},
-					BodyRoot:      []byte{23},
-				},
-				Signature: []byte{24},
-			},
-		},
-	}
-
-	expectedResult := []*structs.ProposerSlashing{
-		{
-			SignedHeader1: &structs.SignedBeaconBlockHeader{
-				Message: &structs.BeaconBlockHeader{
-					Slot:          "1",
-					ProposerIndex: "2",
-					ParentRoot:    hexutil.Encode([]byte{3}),
-					StateRoot:     hexutil.Encode([]byte{4}),
-					BodyRoot:      hexutil.Encode([]byte{5}),
-				},
-				Signature: hexutil.Encode([]byte{6}),
-			},
-			SignedHeader2: &structs.SignedBeaconBlockHeader{
-				Message: &structs.BeaconBlockHeader{
-					Slot:          "7",
-					ProposerIndex: "8",
-					ParentRoot:    hexutil.Encode([]byte{9}),
-					StateRoot:     hexutil.Encode([]byte{10}),
-					BodyRoot:      hexutil.Encode([]byte{11}),
-				},
-				Signature: hexutil.Encode([]byte{12}),
-			},
-		},
-		{
-			SignedHeader1: &structs.SignedBeaconBlockHeader{
-				Message: &structs.BeaconBlockHeader{
-					Slot:          "13",
-					ProposerIndex: "14",
-					ParentRoot:    hexutil.Encode([]byte{15}),
-					StateRoot:     hexutil.Encode([]byte{16}),
-					BodyRoot:      hexutil.Encode([]byte{17}),
-				},
-				Signature: hexutil.Encode([]byte{18}),
-			},
-			SignedHeader2: &structs.SignedBeaconBlockHeader{
-				Message: &structs.BeaconBlockHeader{
-					Slot:          "19",
-					ProposerIndex: "20",
-					ParentRoot:    hexutil.Encode([]byte{21}),
-					StateRoot:     hexutil.Encode([]byte{22}),
-					BodyRoot:      hexutil.Encode([]byte{23}),
-				},
-				Signature: hexutil.Encode([]byte{24}),
-			},
-		},
-	}
-
-	result := jsonifyProposerSlashings(input)
-	assert.DeepEqual(t, expectedResult, result)
-}
-
 func TestBeaconBlockJsonHelpers_JsonifySignedVoluntaryExits(t *testing.T) {
 	input := []*ethpb.SignedVoluntaryExit{
 		{

validator/client/beacon-api/propose_beacon_block.go

@@ -6,192 +6,63 @@ import (
 	"encoding/json"
 	"net/http"
 
-	"github.com/OffchainLabs/prysm/v6/api/apiutil"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/network/httputil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 )
 
-// nolint:gocognit
+type blockProcessingResult struct {
+	consensusVersion string
+	beaconBlockRoot  [32]byte
+	marshalledJSON   []byte
+	blinded          bool
+}
+
 func (c *beaconApiValidatorClient) proposeBeaconBlock(ctx context.Context, in *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
-	var consensusVersion string
-	var beaconBlockRoot [32]byte
-
+	var res *blockProcessingResult
 	var err error
-	var marshalledSignedBeaconBlockJson []byte
-	blinded := false
-
 	switch blockType := in.Block.(type) {
 	case *ethpb.GenericSignedBeaconBlock_Phase0:
-		consensusVersion = "phase0"
-		beaconBlockRoot, err = blockType.Phase0.Block.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for phase0 beacon block")
-		}
-
-		marshalledSignedBeaconBlockJson, err = marshallBeaconBlockPhase0(blockType.Phase0)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshall phase0 beacon block")
-		}
+		res, err = handlePhase0Block(blockType)
 	case *ethpb.GenericSignedBeaconBlock_Altair:
-		consensusVersion = "altair"
-		beaconBlockRoot, err = blockType.Altair.Block.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for altair beacon block")
-		}
-
-		marshalledSignedBeaconBlockJson, err = marshallBeaconBlockAltair(blockType.Altair)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshall altair beacon block")
-		}
+		res, err = handleAltairBlock(blockType)
 	case *ethpb.GenericSignedBeaconBlock_Bellatrix:
-		consensusVersion = "bellatrix"
-		beaconBlockRoot, err = blockType.Bellatrix.Block.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for bellatrix beacon block")
-		}
-
-		marshalledSignedBeaconBlockJson, err = marshallBeaconBlockBellatrix(blockType.Bellatrix)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshall bellatrix beacon block")
-		}
+		res, err = handleBellatrixBlock(blockType)
 	case *ethpb.GenericSignedBeaconBlock_BlindedBellatrix:
-		blinded = true
-		consensusVersion = "bellatrix"
-		beaconBlockRoot, err = blockType.BlindedBellatrix.Block.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for blinded bellatrix beacon block")
-		}
-
-		marshalledSignedBeaconBlockJson, err = marshallBeaconBlockBlindedBellatrix(blockType.BlindedBellatrix)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshall blinded bellatrix beacon block")
-		}
+		res, err = handleBlindedBellatrixBlock(blockType)
 	case *ethpb.GenericSignedBeaconBlock_Capella:
-		consensusVersion = "capella"
-		beaconBlockRoot, err = blockType.Capella.Block.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for capella beacon block")
-		}
-
-		marshalledSignedBeaconBlockJson, err = marshallBeaconBlockCapella(blockType.Capella)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshall capella beacon block")
-		}
+		res, err = handleCapellaBlock(blockType)
 	case *ethpb.GenericSignedBeaconBlock_BlindedCapella:
-		blinded = true
-		consensusVersion = "capella"
-		beaconBlockRoot, err = blockType.BlindedCapella.Block.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for blinded capella beacon block")
-		}
-
-		marshalledSignedBeaconBlockJson, err = marshallBeaconBlockBlindedCapella(blockType.BlindedCapella)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshall blinded capella beacon block")
-		}
+		res, err = handleBlindedCapellaBlock(blockType)
 	case *ethpb.GenericSignedBeaconBlock_Deneb:
-		consensusVersion = "deneb"
-		beaconBlockRoot, err = blockType.Deneb.Block.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for deneb beacon block")
-		}
-		signedBlock, err := structs.SignedBeaconBlockContentsDenebFromConsensus(blockType.Deneb)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert deneb beacon block contents")
-		}
-		marshalledSignedBeaconBlockJson, err = json.Marshal(signedBlock)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshal deneb beacon block contents")
-		}
+		res, err = handleDenebBlockContents(blockType)
 	case *ethpb.GenericSignedBeaconBlock_BlindedDeneb:
-		blinded = true
-		consensusVersion = "deneb"
-		beaconBlockRoot, err = blockType.BlindedDeneb.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for blinded deneb beacon block")
-		}
-		signedBlock, err := structs.SignedBlindedBeaconBlockDenebFromConsensus(blockType.BlindedDeneb)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert blinded deneb beacon block contents")
-		}
-		marshalledSignedBeaconBlockJson, err = json.Marshal(signedBlock)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshal blinded deneb beacon block contents")
-		}
+		res, err = handleBlindedDenebBlock(blockType)
 	case *ethpb.GenericSignedBeaconBlock_Electra:
-		consensusVersion = "electra"
-		beaconBlockRoot, err = blockType.Electra.Block.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for electra beacon block")
-		}
-		signedBlock, err := structs.SignedBeaconBlockContentsElectraFromConsensus(blockType.Electra)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert electra beacon block contents")
-		}
-		marshalledSignedBeaconBlockJson, err = json.Marshal(signedBlock)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshal electra beacon block contents")
-		}
+		res, err = handleElectraBlockContents(blockType)
 	case *ethpb.GenericSignedBeaconBlock_BlindedElectra:
-		blinded = true
-		consensusVersion = "electra"
-		beaconBlockRoot, err = blockType.BlindedElectra.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for blinded electra beacon block")
-		}
-		signedBlock, err := structs.SignedBlindedBeaconBlockElectraFromConsensus(blockType.BlindedElectra)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert blinded electra beacon block contents")
-		}
-		marshalledSignedBeaconBlockJson, err = json.Marshal(signedBlock)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshal blinded electra beacon block contents")
-		}
+		res, err = handleBlindedElectraBlock(blockType)
 	case *ethpb.GenericSignedBeaconBlock_Fulu:
-		consensusVersion = "fulu"
-		beaconBlockRoot, err = blockType.Fulu.Block.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for fulu beacon block")
-		}
-		signedBlock, err := structs.SignedBeaconBlockContentsFuluFromConsensus(blockType.Fulu)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert fulu beacon block contents")
-		}
-		marshalledSignedBeaconBlockJson, err = json.Marshal(signedBlock)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshal fulu beacon block contents")
-		}
+		res, err = handleFuluBlockContents(blockType)
 	case *ethpb.GenericSignedBeaconBlock_BlindedFulu:
-		blinded = true
-		consensusVersion = "fulu"
-		beaconBlockRoot, err = blockType.BlindedFulu.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to compute block root for blinded fulu beacon block")
-		}
-		signedBlock, err := structs.SignedBlindedBeaconBlockFuluFromConsensus(blockType.BlindedFulu)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to convert blinded fulu beacon block contents")
-		}
-		marshalledSignedBeaconBlockJson, err = json.Marshal(signedBlock)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshal blinded fulu beacon block contents")
-		}
+		res, err = handleBlindedFuluBlock(blockType)
 	default:
 		return nil, errors.Errorf("unsupported block type %T", in.Block)
 	}
 
+	if err != nil {
+		return nil, err
+	}
+
 	endpoint := "/eth/v2/beacon/blocks"
 
-	if blinded {
+	if res.blinded {
 		endpoint = "/eth/v2/beacon/blinded_blocks"
 	}
 
-	headers := map[string]string{"Eth-Consensus-Version": consensusVersion}
-	err = c.jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(marshalledSignedBeaconBlockJson), nil)
+	headers := map[string]string{"Eth-Consensus-Version": res.consensusVersion}
+	err = c.jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(res.marshalledJSON), nil)
 	errJson := &httputil.DefaultJsonError{}
 	if err != nil {
 		if !errors.As(err, &errJson) {
@@ -204,237 +75,273 @@ func (c *beaconApiValidatorClient) proposeBeaconBlock(ctx context.Context, in *e
 		return nil, errJson
 	}
 
-	return &ethpb.ProposeResponse{BlockRoot: beaconBlockRoot[:]}, nil
+	return &ethpb.ProposeResponse{BlockRoot: res.beaconBlockRoot[:]}, nil
 }
 
-func marshallBeaconBlockPhase0(block *ethpb.SignedBeaconBlock) ([]byte, error) {
-	signedBeaconBlockJson := &structs.SignedBeaconBlock{
-		Signature: hexutil.Encode(block.Signature),
-		Message: &structs.BeaconBlock{
-			Body: &structs.BeaconBlockBody{
-				Attestations:      jsonifyAttestations(block.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(block.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(block.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(block.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(block.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(block.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(block.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(block.Block.Body.VoluntaryExits),
-			},
-			ParentRoot:    hexutil.Encode(block.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(block.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(block.Block.Slot),
-			StateRoot:     hexutil.Encode(block.Block.StateRoot),
-		},
+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
+
+	signedBlock := structs.SignedBeaconBlockPhase0FromConsensus(block.Phase0)
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall phase0 beacon block to json")
+	}
+	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
+
+	signedBlock := structs.SignedBeaconBlockAltairFromConsensus(block.Altair)
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall altair beacon block to json")
+	}
+	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
+
+	signedBlock, err := structs.SignedBeaconBlockBellatrixFromConsensus(block.Bellatrix)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall bellatrix beacon block")
+	}
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall bellatrix beacon block to json")
 	}
 
-	return json.Marshal(signedBeaconBlockJson)
+	return &res, nil
 }
 
-func marshallBeaconBlockAltair(block *ethpb.SignedBeaconBlockAltair) ([]byte, error) {
-	signedBeaconBlockAltairJson := &structs.SignedBeaconBlockAltair{
-		Signature: hexutil.Encode(block.Signature),
-		Message: &structs.BeaconBlockAltair{
-			ParentRoot:    hexutil.Encode(block.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(block.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(block.Block.Slot),
-			StateRoot:     hexutil.Encode(block.Block.StateRoot),
-			Body: &structs.BeaconBlockBodyAltair{
-				Attestations:      jsonifyAttestations(block.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(block.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(block.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(block.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(block.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(block.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(block.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(block.Block.Body.VoluntaryExits),
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(block.Block.Body.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(block.Block.Body.SyncAggregate.SyncCommitteeSignature),
-				},
-			},
-		},
+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
+
+	signedBlock, err := structs.SignedBlindedBeaconBlockBellatrixFromConsensus(block.BlindedBellatrix)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall blinded bellatrix beacon block")
+	}
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall blinded bellatrix beacon block to json")
 	}
 
-	return json.Marshal(signedBeaconBlockAltairJson)
+	return &res, nil
 }
 
-func marshallBeaconBlockBellatrix(block *ethpb.SignedBeaconBlockBellatrix) ([]byte, error) {
-	signedBeaconBlockBellatrixJson := &structs.SignedBeaconBlockBellatrix{
-		Signature: hexutil.Encode(block.Signature),
-		Message: &structs.BeaconBlockBellatrix{
-			ParentRoot:    hexutil.Encode(block.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(block.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(block.Block.Slot),
-			StateRoot:     hexutil.Encode(block.Block.StateRoot),
-			Body: &structs.BeaconBlockBodyBellatrix{
-				Attestations:      jsonifyAttestations(block.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(block.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(block.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(block.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(block.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(block.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(block.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(block.Block.Body.VoluntaryExits),
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(block.Block.Body.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(block.Block.Body.SyncAggregate.SyncCommitteeSignature),
-				},
-				ExecutionPayload: &structs.ExecutionPayload{
-					ParentHash:    hexutil.Encode(block.Block.Body.ExecutionPayload.ParentHash),
-					FeeRecipient:  hexutil.Encode(block.Block.Body.ExecutionPayload.FeeRecipient),
-					StateRoot:     hexutil.Encode(block.Block.Body.ExecutionPayload.StateRoot),
-					ReceiptsRoot:  hexutil.Encode(block.Block.Body.ExecutionPayload.ReceiptsRoot),
-					LogsBloom:     hexutil.Encode(block.Block.Body.ExecutionPayload.LogsBloom),
-					PrevRandao:    hexutil.Encode(block.Block.Body.ExecutionPayload.PrevRandao),
-					BlockNumber:   apiutil.Uint64ToString(block.Block.Body.ExecutionPayload.BlockNumber),
-					GasLimit:      apiutil.Uint64ToString(block.Block.Body.ExecutionPayload.GasLimit),
-					GasUsed:       apiutil.Uint64ToString(block.Block.Body.ExecutionPayload.GasUsed),
-					Timestamp:     apiutil.Uint64ToString(block.Block.Body.ExecutionPayload.Timestamp),
-					ExtraData:     hexutil.Encode(block.Block.Body.ExecutionPayload.ExtraData),
-					BaseFeePerGas: bytesutil.LittleEndianBytesToBigInt(block.Block.Body.ExecutionPayload.BaseFeePerGas).String(),
-					BlockHash:     hexutil.Encode(block.Block.Body.ExecutionPayload.BlockHash),
-					Transactions:  jsonifyTransactions(block.Block.Body.ExecutionPayload.Transactions),
-				},
-			},
-		},
+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
+
+	signedBlock, err := structs.SignedBeaconBlockCapellaFromConsensus(block.Capella)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall capella beacon block")
+	}
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall capella beacon block to json")
 	}
 
-	return json.Marshal(signedBeaconBlockBellatrixJson)
+	return &res, nil
 }
 
-func marshallBeaconBlockBlindedBellatrix(block *ethpb.SignedBlindedBeaconBlockBellatrix) ([]byte, error) {
-	signedBeaconBlockBellatrixJson := &structs.SignedBlindedBeaconBlockBellatrix{
-		Signature: hexutil.Encode(block.Signature),
-		Message: &structs.BlindedBeaconBlockBellatrix{
-			ParentRoot:    hexutil.Encode(block.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(block.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(block.Block.Slot),
-			StateRoot:     hexutil.Encode(block.Block.StateRoot),
-			Body: &structs.BlindedBeaconBlockBodyBellatrix{
-				Attestations:      jsonifyAttestations(block.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(block.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(block.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(block.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(block.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(block.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(block.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(block.Block.Body.VoluntaryExits),
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(block.Block.Body.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(block.Block.Body.SyncAggregate.SyncCommitteeSignature),
-				},
-				ExecutionPayloadHeader: &structs.ExecutionPayloadHeader{
-					ParentHash:       hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.ParentHash),
-					FeeRecipient:     hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.FeeRecipient),
-					StateRoot:        hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.StateRoot),
-					ReceiptsRoot:     hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.ReceiptsRoot),
-					LogsBloom:        hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.LogsBloom),
-					PrevRandao:       hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.PrevRandao),
-					BlockNumber:      apiutil.Uint64ToString(block.Block.Body.ExecutionPayloadHeader.BlockNumber),
-					GasLimit:         apiutil.Uint64ToString(block.Block.Body.ExecutionPayloadHeader.GasLimit),
-					GasUsed:          apiutil.Uint64ToString(block.Block.Body.ExecutionPayloadHeader.GasUsed),
-					Timestamp:        apiutil.Uint64ToString(block.Block.Body.ExecutionPayloadHeader.Timestamp),
-					ExtraData:        hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.ExtraData),
-					BaseFeePerGas:    bytesutil.LittleEndianBytesToBigInt(block.Block.Body.ExecutionPayloadHeader.BaseFeePerGas).String(),
-					BlockHash:        hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.BlockHash),
-					TransactionsRoot: hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.TransactionsRoot),
-				},
-			},
-		},
+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
+
+	signedBlock, err := structs.SignedBlindedBeaconBlockCapellaFromConsensus(block.BlindedCapella)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall blinded capella beacon block")
+	}
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall blinded capella beacon block to json")
 	}
 
-	return json.Marshal(signedBeaconBlockBellatrixJson)
+	return &res, nil
 }
 
-func marshallBeaconBlockCapella(block *ethpb.SignedBeaconBlockCapella) ([]byte, error) {
-	signedBeaconBlockCapellaJson := &structs.SignedBeaconBlockCapella{
-		Signature: hexutil.Encode(block.Signature),
-		Message: &structs.BeaconBlockCapella{
-			ParentRoot:    hexutil.Encode(block.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(block.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(block.Block.Slot),
-			StateRoot:     hexutil.Encode(block.Block.StateRoot),
-			Body: &structs.BeaconBlockBodyCapella{
-				Attestations:      jsonifyAttestations(block.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(block.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(block.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(block.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(block.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(block.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(block.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(block.Block.Body.VoluntaryExits),
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(block.Block.Body.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(block.Block.Body.SyncAggregate.SyncCommitteeSignature),
-				},
-				ExecutionPayload: &structs.ExecutionPayloadCapella{
-					ParentHash:    hexutil.Encode(block.Block.Body.ExecutionPayload.ParentHash),
-					FeeRecipient:  hexutil.Encode(block.Block.Body.ExecutionPayload.FeeRecipient),
-					StateRoot:     hexutil.Encode(block.Block.Body.ExecutionPayload.StateRoot),
-					ReceiptsRoot:  hexutil.Encode(block.Block.Body.ExecutionPayload.ReceiptsRoot),
-					LogsBloom:     hexutil.Encode(block.Block.Body.ExecutionPayload.LogsBloom),
-					PrevRandao:    hexutil.Encode(block.Block.Body.ExecutionPayload.PrevRandao),
-					BlockNumber:   apiutil.Uint64ToString(block.Block.Body.ExecutionPayload.BlockNumber),
-					GasLimit:      apiutil.Uint64ToString(block.Block.Body.ExecutionPayload.GasLimit),
-					GasUsed:       apiutil.Uint64ToString(block.Block.Body.ExecutionPayload.GasUsed),
-					Timestamp:     apiutil.Uint64ToString(block.Block.Body.ExecutionPayload.Timestamp),
-					ExtraData:     hexutil.Encode(block.Block.Body.ExecutionPayload.ExtraData),
-					BaseFeePerGas: bytesutil.LittleEndianBytesToBigInt(block.Block.Body.ExecutionPayload.BaseFeePerGas).String(),
-					BlockHash:     hexutil.Encode(block.Block.Body.ExecutionPayload.BlockHash),
-					Transactions:  jsonifyTransactions(block.Block.Body.ExecutionPayload.Transactions),
-					Withdrawals:   jsonifyWithdrawals(block.Block.Body.ExecutionPayload.Withdrawals),
-				},
-				BLSToExecutionChanges: jsonifyBlsToExecutionChanges(block.Block.Body.BlsToExecutionChanges),
-			},
-		},
+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
+
+	signedBlock, err := structs.SignedBeaconBlockContentsDenebFromConsensus(block.Deneb)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall deneb beacon block contents")
+	}
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall deneb beacon block contents to json")
 	}
 
-	return json.Marshal(signedBeaconBlockCapellaJson)
+	return &res, nil
 }
 
-func marshallBeaconBlockBlindedCapella(block *ethpb.SignedBlindedBeaconBlockCapella) ([]byte, error) {
-	signedBeaconBlockCapellaJson := &structs.SignedBlindedBeaconBlockCapella{
-		Signature: hexutil.Encode(block.Signature),
-		Message: &structs.BlindedBeaconBlockCapella{
-			ParentRoot:    hexutil.Encode(block.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(block.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(block.Block.Slot),
-			StateRoot:     hexutil.Encode(block.Block.StateRoot),
-			Body: &structs.BlindedBeaconBlockBodyCapella{
-				Attestations:      jsonifyAttestations(block.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(block.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(block.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(block.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(block.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(block.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(block.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(block.Block.Body.VoluntaryExits),
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(block.Block.Body.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(block.Block.Body.SyncAggregate.SyncCommitteeSignature),
-				},
-				ExecutionPayloadHeader: &structs.ExecutionPayloadHeaderCapella{
-					ParentHash:       hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.ParentHash),
-					FeeRecipient:     hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.FeeRecipient),
-					StateRoot:        hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.StateRoot),
-					ReceiptsRoot:     hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.ReceiptsRoot),
-					LogsBloom:        hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.LogsBloom),
-					PrevRandao:       hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.PrevRandao),
-					BlockNumber:      apiutil.Uint64ToString(block.Block.Body.ExecutionPayloadHeader.BlockNumber),
-					GasLimit:         apiutil.Uint64ToString(block.Block.Body.ExecutionPayloadHeader.GasLimit),
-					GasUsed:          apiutil.Uint64ToString(block.Block.Body.ExecutionPayloadHeader.GasUsed),
-					Timestamp:        apiutil.Uint64ToString(block.Block.Body.ExecutionPayloadHeader.Timestamp),
-					ExtraData:        hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.ExtraData),
-					BaseFeePerGas:    bytesutil.LittleEndianBytesToBigInt(block.Block.Body.ExecutionPayloadHeader.BaseFeePerGas).String(),
-					BlockHash:        hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.BlockHash),
-					TransactionsRoot: hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.TransactionsRoot),
-					WithdrawalsRoot:  hexutil.Encode(block.Block.Body.ExecutionPayloadHeader.WithdrawalsRoot),
-				},
-				BLSToExecutionChanges: jsonifyBlsToExecutionChanges(block.Block.Body.BlsToExecutionChanges),
-			},
-		},
+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
+
+	signedBlock, err := structs.SignedBlindedBeaconBlockDenebFromConsensus(block.BlindedDeneb)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall deneb blinded beacon block ")
+	}
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall deneb blinded beacon block to json")
 	}
 
-	return json.Marshal(signedBeaconBlockCapellaJson)
+	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
+
+	signedBlock, err := structs.SignedBeaconBlockContentsElectraFromConsensus(block.Electra)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall electra beacon block contents")
+	}
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall electra beacon block contents to json")
+	}
+
+	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
+
+	signedBlock, err := structs.SignedBlindedBeaconBlockElectraFromConsensus(block.BlindedElectra)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall electra blinded beacon block")
+	}
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall electra blinded beacon block to json")
+	}
+
+	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
+
+	signedBlock, err := structs.SignedBeaconBlockContentsFuluFromConsensus(block.Fulu)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall fulu beacon block contents")
+	}
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall fulu beacon block contents to json")
+	}
+
+	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
+
+	signedBlock, err := structs.SignedBlindedBeaconBlockFuluFromConsensus(block.BlindedFulu)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall fulu blinded beacon block")
+	}
+	res.marshalledJSON, err = json.Marshal(signedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshall fulu blinded beacon block to json")
+	}
+
+	return &res, nil
 }

validator/client/beacon-api/propose_beacon_block_altair_test.go

@@ -6,14 +6,12 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v6/api/apiutil"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
 	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"go.uber.org/mock/gomock"
 )
 
@@ -27,29 +25,7 @@ func TestProposeBeaconBlock_Altair(t *testing.T) {
 	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
 	genericSignedBlock.Block = altairBlock
 
-	jsonAltairBlock := &structs.SignedBeaconBlockAltair{
-		Signature: hexutil.Encode(altairBlock.Altair.Signature),
-		Message: &structs.BeaconBlockAltair{
-			ParentRoot:    hexutil.Encode(altairBlock.Altair.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(altairBlock.Altair.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(altairBlock.Altair.Block.Slot),
-			StateRoot:     hexutil.Encode(altairBlock.Altair.Block.StateRoot),
-			Body: &structs.BeaconBlockBodyAltair{
-				Attestations:      jsonifyAttestations(altairBlock.Altair.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(altairBlock.Altair.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(altairBlock.Altair.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(altairBlock.Altair.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(altairBlock.Altair.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(altairBlock.Altair.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(altairBlock.Altair.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(altairBlock.Altair.Block.Body.VoluntaryExits),
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(altairBlock.Altair.Block.Body.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(altairBlock.Altair.Block.Body.SyncAggregate.SyncCommitteeSignature),
-				},
-			},
-		},
-	}
+	jsonAltairBlock := structs.SignedBeaconBlockAltairFromConsensus(altairBlock.Altair)
 
 	marshalledBlock, err := json.Marshal(jsonAltairBlock)
 	require.NoError(t, err)

validator/client/beacon-api/propose_beacon_block_bellatrix_test.go

@@ -6,15 +6,12 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v6/api/apiutil"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
 	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"go.uber.org/mock/gomock"
 )
 
@@ -28,45 +25,8 @@ func TestProposeBeaconBlock_Bellatrix(t *testing.T) {
 	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
 	genericSignedBlock.Block = bellatrixBlock
 
-	jsonBellatrixBlock := &structs.SignedBeaconBlockBellatrix{
-		Signature: hexutil.Encode(bellatrixBlock.Bellatrix.Signature),
-		Message: &structs.BeaconBlockBellatrix{
-			ParentRoot:    hexutil.Encode(bellatrixBlock.Bellatrix.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(bellatrixBlock.Bellatrix.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(bellatrixBlock.Bellatrix.Block.Slot),
-			StateRoot:     hexutil.Encode(bellatrixBlock.Bellatrix.Block.StateRoot),
-			Body: &structs.BeaconBlockBodyBellatrix{
-				Attestations:      jsonifyAttestations(bellatrixBlock.Bellatrix.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(bellatrixBlock.Bellatrix.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(bellatrixBlock.Bellatrix.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(bellatrixBlock.Bellatrix.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(bellatrixBlock.Bellatrix.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(bellatrixBlock.Bellatrix.Block.Body.VoluntaryExits),
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.SyncAggregate.SyncCommitteeSignature),
-				},
-				ExecutionPayload: &structs.ExecutionPayload{
-					BaseFeePerGas: bytesutil.LittleEndianBytesToBigInt(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.BaseFeePerGas).String(),
-					BlockHash:     hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.BlockHash),
-					BlockNumber:   apiutil.Uint64ToString(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.BlockNumber),
-					ExtraData:     hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.ExtraData),
-					FeeRecipient:  hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.FeeRecipient),
-					GasLimit:      apiutil.Uint64ToString(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.GasLimit),
-					GasUsed:       apiutil.Uint64ToString(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.GasUsed),
-					LogsBloom:     hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.LogsBloom),
-					ParentHash:    hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.ParentHash),
-					PrevRandao:    hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.PrevRandao),
-					ReceiptsRoot:  hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.ReceiptsRoot),
-					StateRoot:     hexutil.Encode(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.StateRoot),
-					Timestamp:     apiutil.Uint64ToString(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.Timestamp),
-					Transactions:  jsonifyTransactions(bellatrixBlock.Bellatrix.Block.Body.ExecutionPayload.Transactions),
-				},
-			},
-		},
-	}
+	jsonBellatrixBlock, err := structs.SignedBeaconBlockBellatrixFromConsensus(bellatrixBlock.Bellatrix)
+	require.NoError(t, err)
 
 	marshalledBlock, err := json.Marshal(jsonBellatrixBlock)
 	require.NoError(t, err)

validator/client/beacon-api/propose_beacon_block_blinded_bellatrix_test.go

@@ -6,16 +6,13 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v6/api/apiutil"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
 	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"go.uber.org/mock/gomock"
 )
 
@@ -29,45 +26,8 @@ func TestProposeBeaconBlock_BlindedBellatrix(t *testing.T) {
 	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
 	genericSignedBlock.Block = blindedBellatrixBlock
 
-	jsonBlindedBellatrixBlock := &structs.SignedBlindedBeaconBlockBellatrix{
-		Signature: hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Signature),
-		Message: &structs.BlindedBeaconBlockBellatrix{
-			ParentRoot:    hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(blindedBellatrixBlock.BlindedBellatrix.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(blindedBellatrixBlock.BlindedBellatrix.Block.Slot),
-			StateRoot:     hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.StateRoot),
-			Body: &structs.BlindedBeaconBlockBodyBellatrix{
-				Attestations:      jsonifyAttestations(blindedBellatrixBlock.BlindedBellatrix.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(blindedBellatrixBlock.BlindedBellatrix.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(blindedBellatrixBlock.BlindedBellatrix.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(blindedBellatrixBlock.BlindedBellatrix.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(blindedBellatrixBlock.BlindedBellatrix.Block.Body.VoluntaryExits),
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.SyncAggregate.SyncCommitteeSignature),
-				},
-				ExecutionPayloadHeader: &structs.ExecutionPayloadHeader{
-					BaseFeePerGas:    bytesutil.LittleEndianBytesToBigInt(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.BaseFeePerGas).String(),
-					BlockHash:        hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.BlockHash),
-					BlockNumber:      apiutil.Uint64ToString(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.BlockNumber),
-					ExtraData:        hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.ExtraData),
-					FeeRecipient:     hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.FeeRecipient),
-					GasLimit:         apiutil.Uint64ToString(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.GasLimit),
-					GasUsed:          apiutil.Uint64ToString(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.GasUsed),
-					LogsBloom:        hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.LogsBloom),
-					ParentHash:       hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.ParentHash),
-					PrevRandao:       hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.PrevRandao),
-					ReceiptsRoot:     hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.ReceiptsRoot),
-					StateRoot:        hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.StateRoot),
-					Timestamp:        apiutil.Uint64ToString(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.Timestamp),
-					TransactionsRoot: hexutil.Encode(blindedBellatrixBlock.BlindedBellatrix.Block.Body.ExecutionPayloadHeader.TransactionsRoot),
-				},
-			},
-		},
-	}
+	jsonBlindedBellatrixBlock, err := structs.SignedBlindedBeaconBlockBellatrixFromConsensus(blindedBellatrixBlock.BlindedBellatrix)
+	require.NoError(t, err)
 
 	marshalledBlock, err := json.Marshal(jsonBlindedBellatrixBlock)
 	require.NoError(t, err)

validator/client/beacon-api/propose_beacon_block_blinded_capella_test.go

@@ -6,16 +6,13 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v6/api/apiutil"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
 	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"go.uber.org/mock/gomock"
 )
 
@@ -29,47 +26,8 @@ func TestProposeBeaconBlock_BlindedCapella(t *testing.T) {
 	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
 	genericSignedBlock.Block = blindedCapellaBlock
 
-	jsonBlindedCapellaBlock := &structs.SignedBlindedBeaconBlockCapella{
-		Signature: hexutil.Encode(blindedCapellaBlock.BlindedCapella.Signature),
-		Message: &structs.BlindedBeaconBlockCapella{
-			ParentRoot:    hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(blindedCapellaBlock.BlindedCapella.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(blindedCapellaBlock.BlindedCapella.Block.Slot),
-			StateRoot:     hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.StateRoot),
-			Body: &structs.BlindedBeaconBlockBodyCapella{
-				Attestations:      jsonifyAttestations(blindedCapellaBlock.BlindedCapella.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(blindedCapellaBlock.BlindedCapella.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(blindedCapellaBlock.BlindedCapella.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(blindedCapellaBlock.BlindedCapella.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(blindedCapellaBlock.BlindedCapella.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(blindedCapellaBlock.BlindedCapella.Block.Body.VoluntaryExits),
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.SyncAggregate.SyncCommitteeSignature),
-				},
-				ExecutionPayloadHeader: &structs.ExecutionPayloadHeaderCapella{
-					BaseFeePerGas:    bytesutil.LittleEndianBytesToBigInt(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.BaseFeePerGas).String(),
-					BlockHash:        hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.BlockHash),
-					BlockNumber:      apiutil.Uint64ToString(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.BlockNumber),
-					ExtraData:        hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.ExtraData),
-					FeeRecipient:     hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.FeeRecipient),
-					GasLimit:         apiutil.Uint64ToString(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.GasLimit),
-					GasUsed:          apiutil.Uint64ToString(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.GasUsed),
-					LogsBloom:        hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.LogsBloom),
-					ParentHash:       hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.ParentHash),
-					PrevRandao:       hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.PrevRandao),
-					ReceiptsRoot:     hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.ReceiptsRoot),
-					StateRoot:        hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.StateRoot),
-					Timestamp:        apiutil.Uint64ToString(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.Timestamp),
-					TransactionsRoot: hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.TransactionsRoot),
-					WithdrawalsRoot:  hexutil.Encode(blindedCapellaBlock.BlindedCapella.Block.Body.ExecutionPayloadHeader.WithdrawalsRoot),
-				},
-				BLSToExecutionChanges: jsonifyBlsToExecutionChanges(blindedCapellaBlock.BlindedCapella.Block.Body.BlsToExecutionChanges),
-			},
-		},
-	}
+	jsonBlindedCapellaBlock, err := structs.SignedBlindedBeaconBlockCapellaFromConsensus(blindedCapellaBlock.BlindedCapella)
+	require.NoError(t, err)
 
 	marshalledBlock, err := json.Marshal(jsonBlindedCapellaBlock)
 	require.NoError(t, err)

validator/client/beacon-api/propose_beacon_block_capella_test.go

@@ -6,15 +6,12 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v6/api/apiutil"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
 	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"go.uber.org/mock/gomock"
 )
 
@@ -28,48 +25,9 @@ func TestProposeBeaconBlock_Capella(t *testing.T) {
 	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
 	genericSignedBlock.Block = capellaBlock
 
-	jsonCapellaBlock := &structs.SignedBeaconBlockCapella{
-		Signature: hexutil.Encode(capellaBlock.Capella.Signature),
-		Message: &structs.BeaconBlockCapella{
-			ParentRoot:    hexutil.Encode(capellaBlock.Capella.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(capellaBlock.Capella.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(capellaBlock.Capella.Block.Slot),
-			StateRoot:     hexutil.Encode(capellaBlock.Capella.Block.StateRoot),
-			Body: &structs.BeaconBlockBodyCapella{
-				Attestations:      jsonifyAttestations(capellaBlock.Capella.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(capellaBlock.Capella.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(capellaBlock.Capella.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(capellaBlock.Capella.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(capellaBlock.Capella.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(capellaBlock.Capella.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(capellaBlock.Capella.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(capellaBlock.Capella.Block.Body.VoluntaryExits),
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(capellaBlock.Capella.Block.Body.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(capellaBlock.Capella.Block.Body.SyncAggregate.SyncCommitteeSignature),
-				},
-				ExecutionPayload: &structs.ExecutionPayloadCapella{
-					BaseFeePerGas: bytesutil.LittleEndianBytesToBigInt(capellaBlock.Capella.Block.Body.ExecutionPayload.BaseFeePerGas).String(),
-					BlockHash:     hexutil.Encode(capellaBlock.Capella.Block.Body.ExecutionPayload.BlockHash),
-					BlockNumber:   apiutil.Uint64ToString(capellaBlock.Capella.Block.Body.ExecutionPayload.BlockNumber),
-					ExtraData:     hexutil.Encode(capellaBlock.Capella.Block.Body.ExecutionPayload.ExtraData),
-					FeeRecipient:  hexutil.Encode(capellaBlock.Capella.Block.Body.ExecutionPayload.FeeRecipient),
-					GasLimit:      apiutil.Uint64ToString(capellaBlock.Capella.Block.Body.ExecutionPayload.GasLimit),
-					GasUsed:       apiutil.Uint64ToString(capellaBlock.Capella.Block.Body.ExecutionPayload.GasUsed),
-					LogsBloom:     hexutil.Encode(capellaBlock.Capella.Block.Body.ExecutionPayload.LogsBloom),
-					ParentHash:    hexutil.Encode(capellaBlock.Capella.Block.Body.ExecutionPayload.ParentHash),
-					PrevRandao:    hexutil.Encode(capellaBlock.Capella.Block.Body.ExecutionPayload.PrevRandao),
-					ReceiptsRoot:  hexutil.Encode(capellaBlock.Capella.Block.Body.ExecutionPayload.ReceiptsRoot),
-					StateRoot:     hexutil.Encode(capellaBlock.Capella.Block.Body.ExecutionPayload.StateRoot),
-					Timestamp:     apiutil.Uint64ToString(capellaBlock.Capella.Block.Body.ExecutionPayload.Timestamp),
-					Transactions:  jsonifyTransactions(capellaBlock.Capella.Block.Body.ExecutionPayload.Transactions),
-					Withdrawals:   jsonifyWithdrawals(capellaBlock.Capella.Block.Body.ExecutionPayload.Withdrawals),
-				},
-				BLSToExecutionChanges: jsonifyBlsToExecutionChanges(capellaBlock.Capella.Block.Body.BlsToExecutionChanges),
-			},
-		},
-	}
-
+	jsonCapellaBlock, err := structs.SignedBeaconBlockCapellaFromConsensus(capellaBlock.Capella)
+	require.NoError(t, err)
+	
 	marshalledBlock, err := json.Marshal(jsonCapellaBlock)
 	require.NoError(t, err)
 

validator/client/beacon-api/propose_beacon_block_phase0_test.go

@@ -6,14 +6,12 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v6/api/apiutil"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
 	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"go.uber.org/mock/gomock"
 )
 
@@ -27,25 +25,7 @@ func TestProposeBeaconBlock_Phase0(t *testing.T) {
 	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
 	genericSignedBlock.Block = phase0Block
 
-	jsonPhase0Block := &structs.SignedBeaconBlock{
-		Signature: hexutil.Encode(phase0Block.Phase0.Signature),
-		Message: &structs.BeaconBlock{
-			ParentRoot:    hexutil.Encode(phase0Block.Phase0.Block.ParentRoot),
-			ProposerIndex: apiutil.Uint64ToString(phase0Block.Phase0.Block.ProposerIndex),
-			Slot:          apiutil.Uint64ToString(phase0Block.Phase0.Block.Slot),
-			StateRoot:     hexutil.Encode(phase0Block.Phase0.Block.StateRoot),
-			Body: &structs.BeaconBlockBody{
-				Attestations:      jsonifyAttestations(phase0Block.Phase0.Block.Body.Attestations),
-				AttesterSlashings: jsonifyAttesterSlashings(phase0Block.Phase0.Block.Body.AttesterSlashings),
-				Deposits:          jsonifyDeposits(phase0Block.Phase0.Block.Body.Deposits),
-				Eth1Data:          jsonifyEth1Data(phase0Block.Phase0.Block.Body.Eth1Data),
-				Graffiti:          hexutil.Encode(phase0Block.Phase0.Block.Body.Graffiti),
-				ProposerSlashings: jsonifyProposerSlashings(phase0Block.Phase0.Block.Body.ProposerSlashings),
-				RandaoReveal:      hexutil.Encode(phase0Block.Phase0.Block.Body.RandaoReveal),
-				VoluntaryExits:    JsonifySignedVoluntaryExits(phase0Block.Phase0.Block.Body.VoluntaryExits),
-			},
-		},
-	}
+	jsonPhase0Block := structs.SignedBeaconBlockPhase0FromConsensus(phase0Block.Phase0)
 
 	marshalledBlock, err := json.Marshal(jsonPhase0Block)
 	require.NoError(t, err)