1/n feat: add preconfirmation support (#3005)

Author: fridrik01

beacon/blockchain/finalize_block.go

@@ -36,6 +36,29 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+// sequencerFinalizeOptimisticBuild triggers an optimistic payload build from FinalizeBlock
+// when ProcessProposal was skipped (e.g., proposal arrived after the CometBFT propose timeout).
+func (s *Service) sequencerFinalizeOptimisticBuild(
+	ctx context.Context,
+	blk *ctypes.BeaconBlock,
+	consensusTime math.U64,
+) {
+	s.logger.Warn("ProcessProposal was skipped, triggering optimistic build from FinalizeBlock",
+		"current_slot", blk.GetSlot().Base10(),
+	)
+
+	st := s.storageBackend.StateFromContext(ctx)
+	ephemeralState := st.Protect(ctx)
+
+	buildData, err := s.preFetchBuildData(ephemeralState, consensusTime)
+	if err != nil {
+		s.logger.Error("Failed to prepare optimistic build data from FinalizeBlock", "error", err)
+		return
+	}
+
+	s.handleOptimisticPayloadBuild(ctx, buildData)
+}
+
 func (s *Service) FinalizeBlock(
 	ctx sdk.Context,
 	req *cmtabci.FinalizeBlockRequest,
@@ -80,7 +103,20 @@ func (s *Service) FinalizeBlock(
 	}
 
 	// STEP 4: Post Finalizations cleanups.
-	return valUpdates, s.PostFinalizeBlockOps(ctx, blk)
+	if err = s.PostFinalizeBlockOps(ctx, blk); err != nil {
+		return valUpdates, err
+	}
+
+	// STEP 5: Sequencer fallback — trigger optimistic build if ProcessProposal was skipped.
+	if s.preconfCfg.IsSequencer() && s.localBuilder.Enabled() {
+		skipped := !s.optimisticBuildTriggered.Load()
+		s.optimisticBuildTriggered.Store(false)
+		if skipped {
+			s.sequencerFinalizeOptimisticBuild(ctx, blk, math.U64(req.GetTime().Unix())) //#nosec: G115
+		}
+	}
+
+	return valUpdates, nil
 }
 
 func (s *Service) FinalizeSidecars(

beacon/blockchain/payload_test.go

@@ -134,6 +134,7 @@ func TestOptimisticBlockBuildingRejectedBlockStateChecks(t *testing.T) {
 		ctx.ConsensusCtx(),
 		types.NewConsensusBlock(invalidBlk, proposerAddress, consensusTime),
 		true, // this block is next block proposer
+		proposerAddress,
 	)
 	require.ErrorIs(t, err, core.ErrProposerMismatch)
 
@@ -241,6 +242,7 @@ func TestOptimisticBlockBuildingVerifiedBlockStateChecks(t *testing.T) {
 		ctx.ConsensusCtx(),
 		types.NewConsensusBlock(validBlk, ctx.ProposerAddress(), consensusTime),
 		true, // this block is next block proposer
+		ctx.ProposerAddress(),
 	)
 	require.NoError(t, err)
 
@@ -282,6 +284,8 @@ func setupOptimisticPayloadTests(t *testing.T, cs chain.Spec) (
 		b,
 		sp,
 		ts,
+		nil, // preconf.Config unused in this test
+		nil, // preconf.Whitelist unused in this test
 	)
 	return chain, st, cms, ctx, sp, b, sb, eng, depStore
 }

beacon/blockchain/process_proposal.go

@@ -23,6 +23,7 @@ package blockchain
 import (
 	"bytes"
 	"context"
+	"encoding/hex"
 	"fmt"
 	"time"
 
@@ -155,6 +156,7 @@ func (s *Service) ProcessProposal(
 		ctx,
 		consensusBlk,
 		bytes.Equal(thisNodeAddress, req.NextProposerAddress),
+		req.NextProposerAddress,
 	)
 	if err != nil {
 		s.logger.Error("failed to verify incoming block", "error", err)
@@ -254,11 +256,12 @@ func (s *Service) VerifyIncomingBlobSidecars(
 // VerifyIncomingBlock verifies the state root of an incoming block
 // and logs the process.
 //
-//nolint:funlen // abundantly commented
+//nolint:funlen,gocognit // abundantly commented
 func (s *Service) VerifyIncomingBlock(
 	ctx context.Context,
 	blk *types.ConsensusBlock,
 	isNextBlockProposer bool,
+	nextProposerAddress []byte,
 ) (transition.ValidatorUpdates, error) {
 	beaconBlk := blk.GetBeaconBlock()
 	state := s.storageBackend.StateFromContext(ctx)
@@ -299,24 +302,50 @@ func (s *Service) VerifyIncomingBlock(
 		return nil, ErrUnexpectedBlockSlot
 	}
 
-	var (
-		nextBlockData          *builder.RequestPayloadData
-		errFetch               error
-		shouldBuildNextPayload = s.shouldBuildNextPayload(isNextBlockProposer)
-	)
+	// Determine if we should optimistically build a payload for the next slot.
+	var shouldBuildNextPayload bool
+	if s.localBuilder.Enabled() {
+		switch {
+		case isNextBlockProposer && !s.preconfCfg.ShouldFetchFromSequencer():
+			// We're the next proposer and not fetching from sequencer,
+			// build optimistically on local EL for ourselves.
+			shouldBuildNextPayload = true
+			s.logger.Info("Next proposer is this node, building optimistically",
+				"current_block_slot", blkSlot.Base10(),
+				"target_build_slot", (blkSlot + 1).Base10(),
+			)
+		case s.preconfCfg.IsSequencer():
+			// We're the sequencer, build for whitelisted validators.
+			// Only check whitelist if we can resolve the next proposer pubkey.
+			expectedProposerPubkey, pubkeyErr := s.getNextProposerPubkey(state, nextProposerAddress)
+			if pubkeyErr != nil {
+				s.logger.Error("Failed to get next proposer pubkey", "error", pubkeyErr)
+			} else {
+				shouldBuildNextPayload = s.preconfWhitelist.IsWhitelisted(expectedProposerPubkey)
+			}
+			s.logger.Info("Sequencer mode: determined next proposer",
+				"current_block_slot", blkSlot.Base10(),
+				"target_build_slot", (blkSlot + 1).Base10(),
+				"next_proposer_address", hex.EncodeToString(nextProposerAddress),
+				"expected_proposer_pubkey", expectedProposerPubkey.String(),
+				"is_whitelisted", shouldBuildNextPayload,
+			)
+		}
+	}
 
+	var nextBlockData *builder.RequestPayloadData
 	if shouldBuildNextPayload {
 		// makes sure that preFetchBuildData does not affect state
 		ephemeralState := state.Protect(ctx)
-		nextBlockData, errFetch = s.preFetchBuildData(ephemeralState, blk.GetConsensusTime())
-		if errFetch != nil {
+		nextBlockData, err = s.preFetchBuildData(ephemeralState, blk.GetConsensusTime())
+		if err != nil {
 			// We don't return with err if pre-fetch fails. Instead we log the issue
 			// and still move to process the current block. Next block can always be
 			// built right after current height is finalized.
 			s.logger.Warn(
 				"Failed pre fetching data for optimistic block building",
-				"case", "block rejectiong",
-				"err", errFetch,
+				"case", "block rejection",
+				"err", err,
 			)
 		}
 	}
@@ -349,18 +378,19 @@ func (s *Service) VerifyIncomingBlock(
 	if shouldBuildNextPayload {
 		// makes sure that preFetchBuildDataForSuccess does not affect state
 		ephemeralState := state.Protect(ctx)
-		nextBlockData, errFetch = s.preFetchBuildData(ephemeralState, blk.GetConsensusTime())
-		if errFetch != nil {
+		nextBlockData, err = s.preFetchBuildData(ephemeralState, blk.GetConsensusTime())
+		if err != nil {
 			// We don't mark the block as rejected if it is valid but pre-fetch fails.
 			// Instead we log the issue and move to process the current block.
 			// Next block can always be built right after current height is finalized.
 			s.logger.Warn(
 				"Failed pre fetching data for optimistic block building",
 				"case", "block success",
-				"err", errFetch,
+				"err", err,
 			)
 			return valUpdates, nil
 		}
+		s.optimisticBuildTriggered.Store(true)
 		go s.handleOptimisticPayloadBuild(ctx, nextBlockData)
 	}
 
@@ -398,8 +428,22 @@ func (s *Service) verifyStateRoot(
 	return valUpdates, err
 }
 
-// shouldBuildNextPayload returns true if optimistic
-// payload builds are enabled.
-func (s *Service) shouldBuildNextPayload(isNextBlockProposer bool) bool {
-	return isNextBlockProposer && s.localBuilder.Enabled()
+// getNextProposerPubkey retrieves the BLS public key for the next proposer given their CometBFT address.
+func (s *Service) getNextProposerPubkey(st *statedb.StateDB, nextProposerAddress []byte) (crypto.BLSPubkey, error) {
+	// Get all validators and find the one matching the CometBFT address
+	validators, err := st.GetValidators()
+	if err != nil {
+		return crypto.BLSPubkey{}, fmt.Errorf("failed to get validators: %w", err)
+	}
+
+	// Find the validator whose BLS pubkey produces the given CometBFT address
+	for _, validator := range validators {
+		pubkey := validator.GetPubkey()
+		computedAddr, _ := crypto.GetAddressFromPubKey(pubkey)
+		if bytes.Equal(computedAddr, nextProposerAddress) {
+			return pubkey, nil
+		}
+	}
+
+	return crypto.BLSPubkey{}, fmt.Errorf("validator not found for address: %x", nextProposerAddress)
 }

beacon/blockchain/service.go

@@ -26,6 +26,7 @@ import (
 	"sync"
 	"sync/atomic"
 
+	"github.com/berachain/beacon-kit/beacon/preconf"
 	engineprimitives "github.com/berachain/beacon-kit/engine-primitives/engine-primitives"
 	"github.com/berachain/beacon-kit/execution/deposit"
 	"github.com/berachain/beacon-kit/log"
@@ -69,6 +70,22 @@ type Service struct {
 	// It helps avoid resending the same FCU data (and spares a network call)
 	// in case optimistic block building is active
 	latestFcuReq atomic.Pointer[engineprimitives.ForkchoiceStateV1]
+
+	// preconfCfg holds the preconfirmation configuration.
+	preconfCfg *preconf.Config
+
+	// preconfWhitelist contains whitelisted validator pubkeys for preconfirmation.
+	// Used by both sequencer and validators:
+	// - Sequencer: checks if next proposer is whitelisted to trigger optimistic FCU
+	// - Validator: checks if self is whitelisted to fetch payload from sequencer
+	// Can be nil if preconf is disabled.
+	preconfWhitelist preconf.Whitelist
+
+	// optimisticBuildTriggered tracks whether ProcessProposal triggered an
+	// optimistic payload build for the next slot. FinalizeBlock checks this
+	// flag: if ProcessProposal was skipped (e.g., late proposal), the flag
+	// remains false and FinalizeBlock triggers the build as a fallback.
+	optimisticBuildTriggered atomic.Bool
 }
 
 // NewService creates a new validator service.
@@ -82,6 +99,8 @@ func NewService(
 	localBuilder LocalBuilder,
 	stateProcessor StateProcessor,
 	telemetrySink TelemetrySink,
+	preconfCfg *preconf.Config,
+	preconfWhitelist preconf.Whitelist,
 ) *Service {
 	return &Service{
 		storageBackend:       storageBackend,
@@ -96,6 +115,8 @@ func NewService(
 		stateProcessor:       stateProcessor,
 		metrics:              newChainMetrics(telemetrySink),
 		forceStartupSyncOnce: new(sync.Once),
+		preconfCfg:           preconfCfg,
+		preconfWhitelist:     preconfWhitelist,
 	}
 }