chore(block-builder): a few minor cleanups

beacon/validator/block_builder.go

@@ -28,8 +28,8 @@ import (
 	payloadtime "github.com/berachain/beacon-kit/beacon/payload-time"
 	ctypes "github.com/berachain/beacon-kit/consensus-types/types"
 	"github.com/berachain/beacon-kit/consensus/types"
-	datypes "github.com/berachain/beacon-kit/da/types"
 	"github.com/berachain/beacon-kit/errors"
+	"github.com/berachain/beacon-kit/payload/builder"
 	"github.com/berachain/beacon-kit/primitives/bytes"
 	"github.com/berachain/beacon-kit/primitives/common"
 	"github.com/berachain/beacon-kit/primitives/crypto"
@@ -41,21 +41,19 @@ import (
 
 // BuildBlockAndSidecars builds a new beacon block.
 //
-//nolint:funlen
+
 func (s *Service) BuildBlockAndSidecars(
 	ctx context.Context,
 	slotData *types.SlotData,
 ) ([]byte, []byte, error) {
-	var (
-		signedBlk *ctypes.SignedBeaconBlock
-		blk       *ctypes.BeaconBlock
-		sidecars  datypes.BlobSidecars
-		forkData  *ctypes.ForkData
-	)
-
 	startTime := time.Now()
 	defer s.metrics.measureRequestBlockForProposalTime(startTime)
 
+	if !s.localPayloadBuilder.Enabled() {
+		// node is not supposed to build blocks
+		return nil, nil, builder.ErrPayloadBuilderDisabled
+	}
+
 	// The goal here is to acquire a payload whose parent is the previously
 	// finalized block, such that, if this payload is accepted, it will be
 	// the next finalized block in the chain. A byproduct of this design
@@ -85,7 +83,7 @@ func (s *Service) BuildBlockAndSidecars(
 	}
 
 	// Create a new empty block from the current state.
-	blk, err = s.getEmptyBeaconBlockForSlot(st, blkSlot)
+	blk, err := s.getEmptyBeaconBlockForSlot(st, blkSlot)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -95,9 +93,6 @@ func (s *Service) BuildBlockAndSidecars(
 	if err != nil {
 		return nil, nil, err
 	}
-	if envelope == nil {
-		return nil, nil, ErrNilPayload
-	}
 
 	// We have to assemble the block body prior to producing the sidecars
 	// since we need to generate the inclusion proofs.
@@ -117,13 +112,13 @@ func (s *Service) BuildBlockAndSidecars(
 	}
 
 	// Craft the signature and signed beacon block.
-	signedBlk, err = ctypes.NewSignedBeaconBlock(blk, forkData, s.chainSpec, s.signer)
+	signedBlk, err := ctypes.NewSignedBeaconBlock(blk, forkData, s.chainSpec, s.signer)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	// Produce blob sidecars with new StateRoot
-	sidecars, err = s.blobFactory.BuildSidecars(signedBlk, envelope.GetBlobsBundle())
+	sidecars, err := s.blobFactory.BuildSidecars(signedBlk, envelope.GetBlobsBundle())
 	if err != nil {
 		return nil, nil, err
 	}
@@ -221,12 +216,11 @@ func (s *Service) retrieveExecutionPayload(
 	// TODO: Add external block builders to this flow.
 	//
 	// Get the payload for the block.
-	envelope, err := s.localPayloadBuilder.
-		RetrievePayload(
-			ctx,
-			blk.GetSlot(),
-			blk.GetParentBlockRoot(),
-		)
+	envelope, err := s.localPayloadBuilder.RetrievePayload(
+		ctx,
+		blk.GetSlot(),
+		blk.GetParentBlockRoot(),
+	)
 	if err == nil {
 		return envelope, nil
 	}
@@ -247,8 +241,7 @@ func (s *Service) retrieveExecutionPayload(
 
 	// The latest execution payload header will be from the previous block
 	// during the block building phase.
-	var lph *ctypes.ExecutionPayloadHeader
-	lph, err = st.GetLatestExecutionPayloadHeader()
+	lph, err := st.GetLatestExecutionPayloadHeader()
 	if err != nil {
 		return nil, err
 	}

beacon/validator/service.go

@@ -50,9 +50,6 @@ type Service struct {
 	// Building blocks are done by submitting forkchoice updates through.
 	// The local Builder.
 	localPayloadBuilder PayloadBuilder
-	// remotePayloadBuilders represents a list of remote block builders, these
-	// builders are connected to other execution clients via the EngineAPI.
-	remotePayloadBuilders []PayloadBuilder
 	// metrics is a metrics collector.
 	metrics *validatorMetrics
 }
@@ -67,20 +64,18 @@ func NewService(
 	signer crypto.BLSSigner,
 	blobFactory BlobFactory,
 	localPayloadBuilder PayloadBuilder,
-	remotePayloadBuilders []PayloadBuilder,
 	ts TelemetrySink,
 ) *Service {
 	return &Service{
-		cfg:                   cfg,
-		logger:                logger,
-		sb:                    sb,
-		chainSpec:             chainSpec,
-		signer:                signer,
-		stateProcessor:        stateProcessor,
-		blobFactory:           blobFactory,
-		localPayloadBuilder:   localPayloadBuilder,
-		remotePayloadBuilders: remotePayloadBuilders,
-		metrics:               newValidatorMetrics(ts),
+		cfg:                 cfg,
+		logger:              logger,
+		sb:                  sb,
+		chainSpec:           chainSpec,
+		signer:              signer,
+		stateProcessor:      stateProcessor,
+		blobFactory:         blobFactory,
+		localPayloadBuilder: localPayloadBuilder,
+		metrics:             newValidatorMetrics(ts),
 	}
 }
 

beacon/validator/types.go

@@ -132,6 +132,9 @@ type ForkData[T any] interface {
 // PayloadBuilder represents a service that is responsible for
 // building eth1 blocks.
 type PayloadBuilder interface {
+	// Enabled may be enabled (e.g. for validators)
+	// or disabled (e.g. full nodes)
+	Enabled() bool
 	// RetrievePayload retrieves the payload for the given slot.
 	RetrievePayload(
 		ctx context.Context,

config/template/template.go

@@ -65,6 +65,8 @@ implementation = "{{.BeaconKit.KZG.Implementation}}"
 
 [beacon-kit.payload-builder]
 # Enabled determines if the local payload builder is enabled.
+# It should be enabled for validators, but it can be disabled
+# for full nodes.
 enabled = {{ .BeaconKit.PayloadBuilder.Enabled }}
 
 # Post bellatrix, this address will receive the transaction fees produced by any blocks

execution/client/ethclient/engine.go

@@ -142,17 +142,14 @@ func (s *Client) GetPayloadV3(
 ) (ctypes.BuiltExecutionPayloadEnv, error) {
 	var t *ctypes.ExecutionPayload
 	result := &ctypes.ExecutionPayloadEnvelope[*engineprimitives.BlobsBundleV1[
-		eip4844.KZGCommitment, eip4844.KZGProof, eip4844.Blob,
+		eip4844.KZGCommitment,
+		eip4844.KZGProof,
+		eip4844.Blob,
 	]]{
 		ExecutionPayload: t.Empty(version.Deneb),
 	}
 
-	if err := s.Call(
-		ctx, result, GetPayloadMethodV3, payloadID,
-	); err != nil {
-		return nil, err
-	}
-	return result, nil
+	return result, s.Call(ctx, result, GetPayloadMethodV3, payloadID)
 }
 
 /* -------------------------------------------------------------------------- */

node-core/components/validator_service.go

@@ -63,9 +63,6 @@ func ProvideValidatorService[
 		in.Signer,
 		in.SidecarFactory,
 		in.LocalBuilder,
-		[]validator.PayloadBuilder{
-			in.LocalBuilder,
-		},
 		in.TelemetrySink,
 	), nil
 }

payload/builder/payload.go

@@ -47,26 +47,27 @@ func (pb *PayloadBuilder) RequestPayloadAsync(
 	}
 
 	if payloadID, found := pb.pc.Get(slot, parentBlockRoot); found {
-		pb.logger.Warn(
+		pb.logger.Info(
 			"aborting payload build; payload already exists in cache",
-			"for_slot",
-			slot.Base10(),
-			"parent_block_root",
-			parentBlockRoot,
+			"for_slot", slot.Base10(),
+			"parent_block_root", parentBlockRoot,
 		)
 		return &payloadID, nil
 	}
 
 	// Assemble the payload attributes.
-	attrs, err := pb.attributesFactory.
-		BuildPayloadAttributes(st, slot, timestamp, parentBlockRoot)
+	attrs, err := pb.attributesFactory.BuildPayloadAttributes(
+		st,
+		slot,
+		timestamp,
+		parentBlockRoot,
+	)
 	if err != nil {
 		return nil, err
 	}
 
 	// Submit the forkchoice update to the execution client.
-	var payloadID *engineprimitives.PayloadID
-	payloadID, _, err = pb.ee.NotifyForkchoiceUpdate(
+	payloadID, _, err := pb.ee.NotifyForkchoiceUpdate(
 		ctx, &ctypes.ForkchoiceUpdateRequest{
 			State: &engineprimitives.ForkchoiceStateV1{
 				HeadBlockHash:      headEth1BlockHash,
@@ -166,29 +167,9 @@ func (pb *PayloadBuilder) RetrievePayload(
 		return nil, err
 	}
 
-	overrideBuilder := envelope.ShouldOverrideBuilder()
-	args := []any{
-		"for_slot", slot.Base10(),
-		"override_builder", overrideBuilder,
-	}
-
-	payload := envelope.GetExecutionPayload()
-	if !payload.IsNil() {
-		args = append(args,
-			"payload_block_hash", payload.GetBlockHash(),
-			"parent_hash", payload.GetParentHash(),
-		)
-	}
-
-	blobsBundle := envelope.GetBlobsBundle()
-	if blobsBundle != nil {
-		args = append(args, "num_blobs", len(blobsBundle.GetBlobs()))
-	}
-
-	pb.logger.Info("Payload retrieved from local builder", args...)
-
 	// If the payload was built by a different builder, something is
 	// wrong the EL<>CL setup.
+	payload := envelope.GetExecutionPayload()
 	if payload.GetFeeRecipient() != pb.cfg.SuggestedFeeRecipient {
 		pb.logger.Warn(
 			"Payload fee recipient does not match suggested fee recipient - "+
@@ -197,6 +178,19 @@ func (pb *PayloadBuilder) RetrievePayload(
 			"suggested_fee_recipient", pb.cfg.SuggestedFeeRecipient,
 		)
 	}
+
+	// log some data
+	args := []any{
+		"for_slot", slot.Base10(),
+		"override_builder", envelope.ShouldOverrideBuilder(),
+		"payload_block_hash", payload.GetBlockHash(),
+		"parent_hash", payload.GetParentHash(),
+	}
+	if blobsBundle := envelope.GetBlobsBundle(); blobsBundle != nil {
+		args = append(args, "num_blobs", len(blobsBundle.GetBlobs()))
+	}
+	pb.logger.Info("Payload retrieved from local builder", args...)
+
 	return envelope, err
 }