New prysm get block RPC

beacon-chain/execution/testing/BUILD.bazel

@@ -26,6 +26,7 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//accounts/abi/bind/backends:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",

beacon-chain/execution/testing/mock_engine_client.go

@@ -15,6 +15,7 @@ import (
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	pb "github.com/prysmaticlabs/prysm/v3/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v3/time/slots"
 )
 
 // EngineClient --
@@ -23,6 +24,7 @@ type EngineClient struct {
 	PayloadIDBytes              *pb.PayloadIDBytes
 	ForkChoiceUpdatedResp       []byte
 	ExecutionPayload            *pb.ExecutionPayload
+	ExecutionPayloadCapella     *pb.ExecutionPayloadCapella
 	ExecutionBlock              *pb.ExecutionBlock
 	Err                         error
 	ErrLatestExecBlock          error
@@ -54,7 +56,10 @@ func (e *EngineClient) ForkchoiceUpdated(
 }
 
 // GetPayload --
-func (e *EngineClient) GetPayload(_ context.Context, _ [8]byte, _ types.Slot) (interfaces.ExecutionData, error) {
+func (e *EngineClient) GetPayload(_ context.Context, _ [8]byte, s types.Slot) (interfaces.ExecutionData, error) {
+	if slots.ToEpoch(s) >= params.BeaconConfig().CapellaForkEpoch {
+		return blocks.WrappedExecutionPayloadCapella(e.ExecutionPayloadCapella)
+	}
 	p, err := blocks.WrappedExecutionPayload(e.ExecutionPayload)
 	if err != nil {
 		return nil, err

beacon-chain/rpc/eth/validator/validator.go

@@ -500,16 +500,9 @@ func (vs *Server) ProduceBlindedBlock(ctx context.Context, req *ethpbv1.ProduceB
 	if optimistic {
 		return nil, status.Errorf(codes.Unavailable, "The node is currently optimistic and cannot serve validators")
 	}
-	altairBlk, err := vs.V1Alpha1Server.BuildAltairBeaconBlock(ctx, v1alpha1req)
+	b, err := vs.V1Alpha1Server.GetBeaconBlock(ctx, v1alpha1req)
 	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not prepare beacon block: %v", err)
-	}
-	ok, b, err := vs.V1Alpha1Server.GetAndBuildBlindBlock(ctx, altairBlk)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not prepare blind beacon block: %v", err)
-	}
-	if !ok {
-		return nil, status.Error(codes.Unavailable, "Builder is not available due to miss-config or circuit breaker")
+		return nil, status.Error(codes.Unavailable, "Could not get block from prysm API")
 	}
 	blk, err := migration.V1Alpha1BeaconBlockBlindedBellatrixToV2Blinded(b.GetBlindedBellatrix())
 	if err != nil {

beacon-chain/rpc/eth/validator/validator_test.go

@@ -689,18 +689,20 @@ func TestProduceBlockV2(t *testing.T) {
 		mockChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:]}
 		mockExecutionChain := &mockExecution.Chain{}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			HeadFetcher:       mockChainService,
-			SyncChecker:       &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:     mockChainService,
-			HeadUpdater:       mockChainService,
-			ChainStartFetcher: mockExecutionChain,
-			Eth1InfoFetcher:   mockExecutionChain,
-			Eth1BlockFetcher:  mockExecutionChain,
-			MockEth1Votes:     true,
-			AttPool:           attestations.NewPool(),
-			SlashingsPool:     slashings.NewPool(),
-			ExitPool:          voluntaryexits.NewPool(),
-			StateGen:          stategen.New(db, doublylinkedtree.New()),
+			HeadFetcher:           mockChainService,
+			SyncChecker:           &mockSync.Sync{IsSyncing: false},
+			BlockReceiver:         mockChainService,
+			HeadUpdater:           mockChainService,
+			ChainStartFetcher:     mockExecutionChain,
+			Eth1InfoFetcher:       mockExecutionChain,
+			Eth1BlockFetcher:      mockExecutionChain,
+			MockEth1Votes:         true,
+			AttPool:               attestations.NewPool(),
+			SlashingsPool:         slashings.NewPool(),
+			ExitPool:              voluntaryexits.NewPool(),
+			StateGen:              stategen.New(db, doublylinkedtree.New()),
+			TimeFetcher:           mockChainService,
+			OptimisticModeFetcher: mockChainService,
 		}
 
 		proposerSlashings := make([]*ethpbalpha.ProposerSlashing, params.BeaconConfig().MaxProposerSlashings)
@@ -797,19 +799,21 @@ func TestProduceBlockV2(t *testing.T) {
 		mochChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:]}
 		mockExecutionChain := &mockExecution.Chain{}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			HeadFetcher:       mochChainService,
-			SyncChecker:       &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:     mochChainService,
-			HeadUpdater:       mochChainService,
-			ChainStartFetcher: mockExecutionChain,
-			Eth1InfoFetcher:   mockExecutionChain,
-			Eth1BlockFetcher:  mockExecutionChain,
-			MockEth1Votes:     true,
-			AttPool:           attestations.NewPool(),
-			SlashingsPool:     slashings.NewPool(),
-			ExitPool:          voluntaryexits.NewPool(),
-			StateGen:          stategen.New(db, doublylinkedtree.New()),
-			SyncCommitteePool: synccommittee.NewStore(),
+			HeadFetcher:           mochChainService,
+			SyncChecker:           &mockSync.Sync{IsSyncing: false},
+			BlockReceiver:         mochChainService,
+			HeadUpdater:           mochChainService,
+			ChainStartFetcher:     mockExecutionChain,
+			Eth1InfoFetcher:       mockExecutionChain,
+			Eth1BlockFetcher:      mockExecutionChain,
+			MockEth1Votes:         true,
+			AttPool:               attestations.NewPool(),
+			SlashingsPool:         slashings.NewPool(),
+			ExitPool:              voluntaryexits.NewPool(),
+			StateGen:              stategen.New(db, doublylinkedtree.New()),
+			SyncCommitteePool:     synccommittee.NewStore(),
+			TimeFetcher:           mochChainService,
+			OptimisticModeFetcher: mochChainService,
 		}
 
 		proposerSlashings := make([]*ethpbalpha.ProposerSlashing, params.BeaconConfig().MaxProposerSlashings)
@@ -2105,6 +2109,14 @@ func TestProduceBlindedBlock(t *testing.T) {
 		require.NoError(t, err)
 		graffiti := bytesutil.ToBytes32([]byte("eth2"))
 
+		copied := beaconState.Copy()
+		require.NoError(t, copied.SetSlot(params.BeaconConfig().SlotsPerEpoch+1))
+		idx, err := helpers.BeaconProposerIndex(ctx, copied)
+		require.NoError(t, err)
+		require.NoError(t,
+			db.SaveRegistrationsByValidatorIDs(ctx, []types.ValidatorIndex{idx},
+				[]*ethpbalpha.ValidatorRegistrationV1{{FeeRecipient: make([]byte, 20), Pubkey: make([]byte, 48)}}))
+
 		req := &ethpbv1.ProduceBlockRequest{
 			Slot:         params.BeaconConfig().SlotsPerEpoch + 1,
 			RandaoReveal: randaoReveal,

beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel

@@ -14,12 +14,12 @@ go_library(
         "proposer_attestations.go",
         "proposer_bellatrix.go",
         "proposer_builder.go",
+        "proposer_capella.go",
         "proposer_deposits.go",
         "proposer_empty_block.go",
         "proposer_eth1data.go",
         "proposer_execution_payload.go",
         "proposer_exits.go",
-        "proposer_phase0.go",
         "proposer_slashings.go",
         "proposer_sync_aggregate.go",
         "server.go",
@@ -44,12 +44,12 @@ go_library(
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
-        "//beacon-chain/core/transition/interop:go_default_library",
         "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/kv:go_default_library",
         "//beacon-chain/execution:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
+        "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/synccommittee:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
@@ -125,6 +125,7 @@ common_deps = [
     "//beacon-chain/operations/synccommittee:go_default_library",
     "//beacon-chain/operations/voluntaryexits:go_default_library",
     "//beacon-chain/p2p/testing:go_default_library",
+    "//beacon-chain/rpc/testutil:go_default_library",
     "//beacon-chain/state:go_default_library",
     "//beacon-chain/state/state-native:go_default_library",
     "//beacon-chain/state/stategen:go_default_library",
@@ -174,6 +175,7 @@ go_test(
         "attester_test.go",
         "blocks_test.go",
         "exit_test.go",
+        "proposer_altair_test.go",
         "proposer_attestations_test.go",
         "proposer_bellatrix_test.go",
         "proposer_builder_test.go",

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

@@ -14,6 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/builder"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed"
 	blockfeed "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed/block"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/db/kv"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
@@ -41,26 +42,110 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	ctx, span := trace.StartSpan(ctx, "ProposerServer.GetBeaconBlock")
 	defer span.End()
 	span.AddAttributes(trace.Int64Attribute("slot", int64(req.Slot)))
-	if slots.ToEpoch(req.Slot) < params.BeaconConfig().AltairForkEpoch {
-		blk, err := vs.getPhase0BeaconBlock(ctx, req)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not fetch phase0 beacon block: %v", err)
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Phase0{Phase0: blk}}, nil
-	} else if slots.ToEpoch(req.Slot) < params.BeaconConfig().BellatrixForkEpoch {
-		blk, err := vs.getAltairBeaconBlock(ctx, req)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not fetch Altair beacon block: %v", err)
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Altair{Altair: blk}}, nil
+
+	// A syncing validator should not produce a block.
+	if vs.SyncChecker.Syncing() {
+		return nil, status.Error(codes.Unavailable, "Syncing to latest head, not ready to respond")
 	}
 
 	// An optimistic validator MUST NOT produce a block (i.e., sign across the DOMAIN_BEACON_PROPOSER domain).
-	if err := vs.optimisticStatus(ctx); err != nil {
-		return nil, err
+	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().BellatrixForkEpoch {
+		if err := vs.optimisticStatus(ctx); err != nil {
+			return nil, status.Errorf(codes.Unavailable, "Validator is not ready to propose: %v", err)
+		}
+	}
+
+	sBlk, err := getEmptyBlock(req.Slot)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not prepare block: %v", err)
+	}
+	parentRoot, err := vs.HeadFetcher.HeadRoot(ctx)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not get head root: %v", err)
 	}
+	head, err := vs.HeadFetcher.HeadState(ctx)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not get head state: %v", err)
+	}
+	head, err = transition.ProcessSlotsUsingNextSlotCache(ctx, head, parentRoot, req.Slot)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not process slots up to %d: %v", req.Slot, err)
+	}
+
+	blk := sBlk.Block()
+	// Set slot, graffiti, randao reveal, and parent root.
+	blk.SetSlot(req.Slot)
+	blk.Body().SetGraffiti(req.Graffiti)
+	blk.Body().SetRandaoReveal(req.RandaoReveal)
+	blk.SetParentRoot(parentRoot)
 
-	return vs.getBellatrixBeaconBlock(ctx, req)
+	// Set eth1 data.
+	eth1Data, err := vs.eth1DataMajorityVote(ctx, head)
+	if err != nil {
+		eth1Data = &ethpb.Eth1Data{DepositRoot: params.BeaconConfig().ZeroHash[:], BlockHash: params.BeaconConfig().ZeroHash[:]}
+		log.WithError(err).Error("Could not get eth1data")
+	}
+	blk.Body().SetEth1Data(eth1Data)
+
+	// Set deposit and attestation.
+	deposits, atts, err := vs.packDepositsAndAttestations(ctx, head, eth1Data) // TODO: split attestations and deposits
+	if err != nil {
+		blk.Body().SetDeposits([]*ethpb.Deposit{})
+		blk.Body().SetAttestations([]*ethpb.Attestation{})
+		log.WithError(err).Error("Could not pack deposits and attestations")
+	}
+	blk.Body().SetDeposits(deposits)
+	blk.Body().SetAttestations(atts)
+
+	// Set proposer index.
+	idx, err := helpers.BeaconProposerIndex(ctx, head)
+	if err != nil {
+		return nil, fmt.Errorf("could not calculate proposer index %v", err)
+	}
+	blk.SetProposerIndex(idx)
+
+	// Set slashings.
+	validProposerSlashings, validAttSlashings := vs.getSlashings(ctx, head)
+	blk.Body().SetProposerSlashings(validProposerSlashings)
+	blk.Body().SetAttesterSlashings(validAttSlashings)
+
+	// Set exits.
+	blk.Body().SetVoluntaryExits(vs.getExits(head, req.Slot))
+
+	// Set sync aggregate. New in Altair.
+	vs.setSyncAggregate(ctx, blk)
+
+	// Set execution data. New in Bellatrix.
+	if err := vs.setExecutionData(ctx, blk, head); err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not set execution data: %v", err)
+	}
+
+	// Set bls to execution change. New in Capella.
+	vs.setBlsToExecData(blk, head)
+
+	sr, err := vs.computeStateRoot(ctx, sBlk)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not compute state root: %v", err)
+	}
+	blk.SetStateRoot(sr)
+
+	pb, err := blk.Proto()
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not convert block to proto: %v", err)
+	}
+	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().CapellaForkEpoch {
+		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Capella{Capella: pb.(*ethpb.BeaconBlockCapella)}}, nil
+	}
+	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().BellatrixForkEpoch && !blk.IsBlinded() {
+		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Bellatrix{Bellatrix: pb.(*ethpb.BeaconBlockBellatrix)}}, nil
+	}
+	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().BellatrixForkEpoch && blk.IsBlinded() {
+		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedBellatrix{BlindedBellatrix: pb.(*ethpb.BlindedBeaconBlockBellatrix)}}, nil
+	}
+	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().AltairForkEpoch {
+		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Altair{Altair: pb.(*ethpb.BeaconBlockAltair)}}, nil
+	}
+	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Phase0{Phase0: pb.(*ethpb.BeaconBlock)}}, nil
 }
 
 // ProposeBeaconBlock is called by a proposer during its assigned slot to create a block in an attempt