diff --git a/api/server/structs/BUILD.bazel b/api/server/structs/BUILD.bazel index 3a89e86cd2..9367483349 100644 --- a/api/server/structs/BUILD.bazel +++ b/api/server/structs/BUILD.bazel @@ -57,6 +57,7 @@ go_test( deps = [ "//proto/engine/v1:go_default_library", "//proto/prysm/v1alpha1:go_default_library", + "//testing/assert:go_default_library", "//testing/require:go_default_library", "@com_github_ethereum_go_ethereum//common:go_default_library", "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library", diff --git a/api/server/structs/conversions_test.go b/api/server/structs/conversions_test.go index dbcbdff2a7..fae4ecefbe 100644 --- a/api/server/structs/conversions_test.go +++ b/api/server/structs/conversions_test.go @@ -4,7 +4,9 @@ import ( "testing" eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1" + "github.com/OffchainLabs/prysm/v6/testing/assert" "github.com/OffchainLabs/prysm/v6/testing/require" + "github.com/ethereum/go-ethereum/common/hexutil" ) func TestDepositSnapshotFromConsensus(t *testing.T) { @@ -102,12 +104,266 @@ func TestProposerSlashing_ToConsensus(t *testing.T) { require.ErrorContains(t, errNilValue.Error(), err) } +func TestProposerSlashing_FromConsensus(t *testing.T) { + input := []*eth.ProposerSlashing{ + { + Header_1: ð.SignedBeaconBlockHeader{ + Header: ð.BeaconBlockHeader{ + Slot: 1, + ProposerIndex: 2, + ParentRoot: []byte{3}, + StateRoot: []byte{4}, + BodyRoot: []byte{5}, + }, + Signature: []byte{6}, + }, + Header_2: ð.SignedBeaconBlockHeader{ + Header: ð.BeaconBlockHeader{ + Slot: 7, + ProposerIndex: 8, + ParentRoot: []byte{9}, + StateRoot: []byte{10}, + BodyRoot: []byte{11}, + }, + Signature: []byte{12}, + }, + }, + { + Header_1: ð.SignedBeaconBlockHeader{ + Header: ð.BeaconBlockHeader{ + Slot: 13, + ProposerIndex: 14, + ParentRoot: []byte{15}, + StateRoot: []byte{16}, + BodyRoot: []byte{17}, + }, + Signature: []byte{18}, + }, + Header_2: ð.SignedBeaconBlockHeader{ + Header: ð.BeaconBlockHeader{ + Slot: 19, + ProposerIndex: 20, + ParentRoot: []byte{21}, + StateRoot: []byte{22}, + BodyRoot: []byte{23}, + }, + Signature: []byte{24}, + }, + }, + } + + expectedResult := []*ProposerSlashing{ + { + SignedHeader1: &SignedBeaconBlockHeader{ + Message: &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: &SignedBeaconBlockHeader{ + Message: &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: &SignedBeaconBlockHeader{ + Message: &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: &SignedBeaconBlockHeader{ + Message: &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 := ProposerSlashingsFromConsensus(input) + assert.DeepEqual(t, expectedResult, result) +} + func TestAttesterSlashing_ToConsensus(t *testing.T) { a := &AttesterSlashing{Attestation1: nil, Attestation2: nil} _, err := a.ToConsensus() require.ErrorContains(t, errNilValue.Error(), err) } +func TestAttesterSlashing_FromConsensus(t *testing.T) { + input := []*eth.AttesterSlashing{ + { + Attestation_1: ð.IndexedAttestation{ + AttestingIndices: []uint64{1, 2}, + Data: ð.AttestationData{ + Slot: 3, + CommitteeIndex: 4, + BeaconBlockRoot: []byte{5}, + Source: ð.Checkpoint{ + Epoch: 6, + Root: []byte{7}, + }, + Target: ð.Checkpoint{ + Epoch: 8, + Root: []byte{9}, + }, + }, + Signature: []byte{10}, + }, + Attestation_2: ð.IndexedAttestation{ + AttestingIndices: []uint64{11, 12}, + Data: ð.AttestationData{ + Slot: 13, + CommitteeIndex: 14, + BeaconBlockRoot: []byte{15}, + Source: ð.Checkpoint{ + Epoch: 16, + Root: []byte{17}, + }, + Target: ð.Checkpoint{ + Epoch: 18, + Root: []byte{19}, + }, + }, + Signature: []byte{20}, + }, + }, + { + Attestation_1: ð.IndexedAttestation{ + AttestingIndices: []uint64{21, 22}, + Data: ð.AttestationData{ + Slot: 23, + CommitteeIndex: 24, + BeaconBlockRoot: []byte{25}, + Source: ð.Checkpoint{ + Epoch: 26, + Root: []byte{27}, + }, + Target: ð.Checkpoint{ + Epoch: 28, + Root: []byte{29}, + }, + }, + Signature: []byte{30}, + }, + Attestation_2: ð.IndexedAttestation{ + AttestingIndices: []uint64{31, 32}, + Data: ð.AttestationData{ + Slot: 33, + CommitteeIndex: 34, + BeaconBlockRoot: []byte{35}, + Source: ð.Checkpoint{ + Epoch: 36, + Root: []byte{37}, + }, + Target: ð.Checkpoint{ + Epoch: 38, + Root: []byte{39}, + }, + }, + Signature: []byte{40}, + }, + }, + } + + expectedResult := []*AttesterSlashing{ + { + Attestation1: &IndexedAttestation{ + AttestingIndices: []string{"1", "2"}, + Data: &AttestationData{ + Slot: "3", + CommitteeIndex: "4", + BeaconBlockRoot: hexutil.Encode([]byte{5}), + Source: &Checkpoint{ + Epoch: "6", + Root: hexutil.Encode([]byte{7}), + }, + Target: &Checkpoint{ + Epoch: "8", + Root: hexutil.Encode([]byte{9}), + }, + }, + Signature: hexutil.Encode([]byte{10}), + }, + Attestation2: &IndexedAttestation{ + AttestingIndices: []string{"11", "12"}, + Data: &AttestationData{ + Slot: "13", + CommitteeIndex: "14", + BeaconBlockRoot: hexutil.Encode([]byte{15}), + Source: &Checkpoint{ + Epoch: "16", + Root: hexutil.Encode([]byte{17}), + }, + Target: &Checkpoint{ + Epoch: "18", + Root: hexutil.Encode([]byte{19}), + }, + }, + Signature: hexutil.Encode([]byte{20}), + }, + }, + { + Attestation1: &IndexedAttestation{ + AttestingIndices: []string{"21", "22"}, + Data: &AttestationData{ + Slot: "23", + CommitteeIndex: "24", + BeaconBlockRoot: hexutil.Encode([]byte{25}), + Source: &Checkpoint{ + Epoch: "26", + Root: hexutil.Encode([]byte{27}), + }, + Target: &Checkpoint{ + Epoch: "28", + Root: hexutil.Encode([]byte{29}), + }, + }, + Signature: hexutil.Encode([]byte{30}), + }, + Attestation2: &IndexedAttestation{ + AttestingIndices: []string{"31", "32"}, + Data: &AttestationData{ + Slot: "33", + CommitteeIndex: "34", + BeaconBlockRoot: hexutil.Encode([]byte{35}), + Source: &Checkpoint{ + Epoch: "36", + Root: hexutil.Encode([]byte{37}), + }, + Target: &Checkpoint{ + Epoch: "38", + Root: hexutil.Encode([]byte{39}), + }, + }, + Signature: hexutil.Encode([]byte{40}), + }, + }, + } + + result := AttesterSlashingsFromConsensus(input) + assert.DeepEqual(t, expectedResult, result) +} + func TestIndexedAttestation_ToConsensus(t *testing.T) { a := &IndexedAttestation{ AttestingIndices: []string{"1"}, diff --git a/changelog/james-prysm_deduplicate-propose-block-marshalling.md b/changelog/james-prysm_deduplicate-propose-block-marshalling.md new file mode 100644 index 0000000000..ab2957b938 --- /dev/null +++ b/changelog/james-prysm_deduplicate-propose-block-marshalling.md @@ -0,0 +1,7 @@ +### Fixed + +- Fixed gocognit on propose block rest path. + +### Ignored + +- Removed jsonify functions that duplicate FromConsensus functions in the structs package for rest calls on propose block. \ No newline at end of file diff --git a/validator/client/beacon-api/beacon_block_json_helpers.go b/validator/client/beacon-api/beacon_block_json_helpers.go index 4f1a2563b2..336f2431e8 100644 --- a/validator/client/beacon-api/beacon_block_json_helpers.go +++ b/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)) diff --git a/validator/client/beacon-api/beacon_block_json_helpers_test.go b/validator/client/beacon-api/beacon_block_json_helpers_test.go index c7c2a1962a..bd864159e9 100644 --- a/validator/client/beacon-api/beacon_block_json_helpers_test.go +++ b/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: ðpb.IndexedAttestation{ - AttestingIndices: []uint64{1, 2}, - Data: ðpb.AttestationData{ - Slot: 3, - CommitteeIndex: 4, - BeaconBlockRoot: []byte{5}, - Source: ðpb.Checkpoint{ - Epoch: 6, - Root: []byte{7}, - }, - Target: ðpb.Checkpoint{ - Epoch: 8, - Root: []byte{9}, - }, - }, - Signature: []byte{10}, - }, - Attestation_2: ðpb.IndexedAttestation{ - AttestingIndices: []uint64{11, 12}, - Data: ðpb.AttestationData{ - Slot: 13, - CommitteeIndex: 14, - BeaconBlockRoot: []byte{15}, - Source: ðpb.Checkpoint{ - Epoch: 16, - Root: []byte{17}, - }, - Target: ðpb.Checkpoint{ - Epoch: 18, - Root: []byte{19}, - }, - }, - Signature: []byte{20}, - }, - }, - { - Attestation_1: ðpb.IndexedAttestation{ - AttestingIndices: []uint64{21, 22}, - Data: ðpb.AttestationData{ - Slot: 23, - CommitteeIndex: 24, - BeaconBlockRoot: []byte{25}, - Source: ðpb.Checkpoint{ - Epoch: 26, - Root: []byte{27}, - }, - Target: ðpb.Checkpoint{ - Epoch: 28, - Root: []byte{29}, - }, - }, - Signature: []byte{30}, - }, - Attestation_2: ðpb.IndexedAttestation{ - AttestingIndices: []uint64{31, 32}, - Data: ðpb.AttestationData{ - Slot: 33, - CommitteeIndex: 34, - BeaconBlockRoot: []byte{35}, - Source: ðpb.Checkpoint{ - Epoch: 36, - Root: []byte{37}, - }, - Target: ðpb.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: ðpb.Deposit_Data{ - PublicKey: []byte{3}, - WithdrawalCredentials: []byte{4}, - Amount: 5, - Signature: []byte{6}, - }, - }, - { - Proof: [][]byte{ - {7}, - {8}, - }, - Data: ðpb.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: ðpb.SignedBeaconBlockHeader{ - Header: ðpb.BeaconBlockHeader{ - Slot: 1, - ProposerIndex: 2, - ParentRoot: []byte{3}, - StateRoot: []byte{4}, - BodyRoot: []byte{5}, - }, - Signature: []byte{6}, - }, - Header_2: ðpb.SignedBeaconBlockHeader{ - Header: ðpb.BeaconBlockHeader{ - Slot: 7, - ProposerIndex: 8, - ParentRoot: []byte{9}, - StateRoot: []byte{10}, - BodyRoot: []byte{11}, - }, - Signature: []byte{12}, - }, - }, - { - Header_1: ðpb.SignedBeaconBlockHeader{ - Header: ðpb.BeaconBlockHeader{ - Slot: 13, - ProposerIndex: 14, - ParentRoot: []byte{15}, - StateRoot: []byte{16}, - BodyRoot: []byte{17}, - }, - Signature: []byte{18}, - }, - Header_2: ðpb.SignedBeaconBlockHeader{ - Header: ðpb.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{ { diff --git a/validator/client/beacon-api/propose_beacon_block.go b/validator/client/beacon-api/propose_beacon_block.go index d18379e00d..ba7ef871ce 100644 --- a/validator/client/beacon-api/propose_beacon_block.go +++ b/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 ðpb.ProposeResponse{BlockRoot: beaconBlockRoot[:]}, nil + return ðpb.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 } diff --git a/validator/client/beacon-api/propose_beacon_block_altair_test.go b/validator/client/beacon-api/propose_beacon_block_altair_test.go index 5287f886a1..6e3eee6402 100644 --- a/validator/client/beacon-api/propose_beacon_block_altair_test.go +++ b/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 := ðpb.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) diff --git a/validator/client/beacon-api/propose_beacon_block_bellatrix_test.go b/validator/client/beacon-api/propose_beacon_block_bellatrix_test.go index 16117a0f6b..c764947cee 100644 --- a/validator/client/beacon-api/propose_beacon_block_bellatrix_test.go +++ b/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 := ðpb.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) diff --git a/validator/client/beacon-api/propose_beacon_block_blinded_bellatrix_test.go b/validator/client/beacon-api/propose_beacon_block_blinded_bellatrix_test.go index e96ffe45bc..a23384cf0b 100644 --- a/validator/client/beacon-api/propose_beacon_block_blinded_bellatrix_test.go +++ b/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 := ðpb.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) diff --git a/validator/client/beacon-api/propose_beacon_block_blinded_capella_test.go b/validator/client/beacon-api/propose_beacon_block_blinded_capella_test.go index fe8d4a809d..59f8a32058 100644 --- a/validator/client/beacon-api/propose_beacon_block_blinded_capella_test.go +++ b/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 := ðpb.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) diff --git a/validator/client/beacon-api/propose_beacon_block_capella_test.go b/validator/client/beacon-api/propose_beacon_block_capella_test.go index 5ddcd6bb6f..a26108bf5d 100644 --- a/validator/client/beacon-api/propose_beacon_block_capella_test.go +++ b/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 := ðpb.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) diff --git a/validator/client/beacon-api/propose_beacon_block_phase0_test.go b/validator/client/beacon-api/propose_beacon_block_phase0_test.go index 8522819b18..7f441e336c 100644 --- a/validator/client/beacon-api/propose_beacon_block_phase0_test.go +++ b/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 := ðpb.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)