fix merge errors

This reverts commit f99a0419ef.

beacon-chain/blockchain/options.go

@@ -11,6 +11,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
+	v1 "github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -50,6 +51,14 @@ func WithChainStartFetcher(f powchain.ChainStartFetcher) Option {
 	}
 }
 
+// WithExecutionEngineCaller to call execution engine.
+func WithExecutionEngineCaller(c v1.Caller) Option {
+	return func(s *Service) error {
+		s.cfg.ExecutionEngineCaller = c
+		return nil
+	}
+}
+
 // WithDepositCache for deposit lifecycle after chain inclusion.
 func WithDepositCache(c *depositcache.DepositCache) Option {
 	return func(s *Service) error {

beacon-chain/blockchain/process_block.go

@@ -1,11 +1,16 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -17,11 +22,14 @@ import (
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
+	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
@@ -97,12 +105,76 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	if err != nil {
 		return err
 	}
+	// TODO_MERGE: Optimize this copy.
+	copiedPreState := preState.Copy()
 
+	body := signed.Block().Body()
+	// TODO_MERGE: Break `ExecuteStateTransition` into per_slot and block processing so we can call `ExecutePayload` in the middle.
 	postState, err := transition.ExecuteStateTransition(ctx, preState, signed)
 	if err != nil {
+		// TODO_MERGE: Notify execution client in the event of invalid conensus block
 		return err
 	}
 
+	fullyValidated := false
+	if copiedPreState.Version() == version.Bellatrix || postState.Version() == version.Bellatrix {
+		executionEnabled, err := blocks.ExecutionEnabled(postState, body)
+		if err != nil {
+			return errors.Wrap(err, "could not check if execution is enabled")
+		}
+		if executionEnabled {
+			payload, err := body.ExecutionPayload()
+			if err != nil {
+				return errors.Wrap(err, "could not get body execution payload")
+			}
+			// This is not the earliest we can call `ExecutePayload`, see above to do as the soonest we can call is after per_slot processing.
+			status, err := s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload)
+			if err != nil {
+				return err
+			}
+			log.WithFields(logrus.Fields{
+				"status:":    status.Status,
+				"hash:":      fmt.Sprintf("%#x", payload.BlockHash),
+				"parentHash": fmt.Sprintf("%#x", payload.ParentHash),
+			}).Info("Successfully called newPayload")
+
+			switch status.Status {
+			case enginev1.PayloadStatus_INVALID, enginev1.PayloadStatus_INVALID_BLOCK_HASH, enginev1.PayloadStatus_INVALID_TERMINAL_BLOCK:
+				// TODO_MERGE walk up the parent chain removing
+				return fmt.Errorf("could not prcess execution payload with status : %v", status.Status)
+			case enginev1.PayloadStatus_SYNCING, enginev1.PayloadStatus_ACCEPTED:
+				candidate, err := s.optimisticCandidateBlock(ctx, b)
+				if err != nil {
+					return errors.Wrap(err, "could not check if block is optimistic candidate")
+				}
+				if !candidate {
+					return errors.New("could not optimistically sync block")
+				}
+				log.WithFields(logrus.Fields{
+					"slot":        b.Slot(),
+					"root":        fmt.Sprintf("%#x", bytesutil.Trunc(blockRoot[:])),
+					"payloadHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash)),
+				}).Info("Block is optimistic candidate")
+				break
+			case enginev1.PayloadStatus_VALID:
+				fullyValidated = true
+			default:
+				return errors.New("unknown payload status")
+			}
+			if fullyValidated {
+				mergeBlock, err := blocks.MergeTransitionBlock(copiedPreState, body)
+				if err != nil {
+					return errors.Wrap(err, "could not check if merge block is terminal")
+				}
+				if mergeBlock {
+					if err := s.validateTerminalBlock(ctx, signed); err != nil {
+						return err
+					}
+				}
+			}
+		}
+	}
+
 	// We add a proposer score boost to fork choice for the block root if applicable, right after
 	// running a successful state transition for the block.
 	if err := s.cfg.ForkChoiceStore.BoostProposerRoot(
@@ -115,6 +187,20 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 		return err
 	}
 
+	// update forkchoice synced tips if the block is not optimistic
+	if postState.Version() == version.Bellatrix || fullyValidated {
+		root, err := b.HashTreeRoot()
+		if err != nil {
+			return err
+		}
+		if err := s.cfg.ForkChoiceStore.UpdateSyncedTipsWithValidRoot(ctx, root); err != nil {
+			return err
+		}
+		if err := s.saveSyncedTipsDB(ctx); err != nil {
+			return err
+		}
+	}
+
 	// If slasher is configured, forward the attestations in the block via
 	// an event feed for processing.
 	if features.Get().EnableSlasher {
@@ -175,8 +261,63 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 		log.WithError(err).Warn("Could not update head")
 	}
 
-	if err := s.saveSyncedTipsDB(ctx); err != nil {
-		return errors.Wrap(err, "could not save synced tips")
+	// Notify execution layer with fork choice head update if this is post merge block.
+	if postState.Version() == version.Bellatrix {
+		executionEnabled, err := blocks.ExecutionEnabled(postState, body)
+		if err != nil {
+			return errors.Wrap(err, "could not check if execution is enabled")
+		}
+		if executionEnabled {
+			headPayload, err := s.headBlock().Block().Body().ExecutionPayload()
+			if err != nil {
+				return err
+			}
+			// TODO_MERGE: Loading the finalized block from DB on per block is not ideal. Finalized block should be cached here
+			finalizedBlock, err := s.cfg.BeaconDB.Block(ctx, bytesutil.ToBytes32(finalized.Root))
+			if err != nil {
+				return err
+			}
+			finalizedBlockHash := params.BeaconConfig().ZeroHash[:]
+			if finalizedBlock != nil && finalizedBlock.Version() == version.Bellatrix {
+				finalizedPayload, err := finalizedBlock.Block().Body().ExecutionPayload()
+				if err != nil {
+					return err
+				}
+				finalizedBlockHash = finalizedPayload.BlockHash
+			}
+
+			fcs := &enginev1.ForkchoiceState{
+				HeadBlockHash:      headPayload.BlockHash,
+				SafeBlockHash:      headPayload.BlockHash,
+				FinalizedBlockHash: finalizedBlockHash,
+			}
+			resp, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, nil /* attribute */)
+			if err != nil {
+				return err
+			}
+
+			log.WithFields(logrus.Fields{
+				"status:": resp.Status.Status,
+				"hash:":   fmt.Sprintf("%#x", headPayload.BlockHash),
+			}).Info("Successfully called forkchoiceUpdated")
+
+			switch resp.Status.Status {
+			case enginev1.PayloadStatus_INVALID, enginev1.PayloadStatus_INVALID_BLOCK_HASH, enginev1.PayloadStatus_INVALID_TERMINAL_BLOCK:
+				return fmt.Errorf("could not prcess execution payload with status : %v", resp.Status.Status)
+			case enginev1.PayloadStatus_SYNCING, enginev1.PayloadStatus_ACCEPTED:
+				candidate, err := s.optimisticCandidateBlock(ctx, b)
+				if err != nil {
+					return errors.Wrap(err, "could not check if block is optimistic candidate")
+				}
+				if !candidate {
+					return errors.Wrap(err, "could not optimistically sync block")
+				}
+				break
+			case enginev1.PayloadStatus_VALID:
+			default:
+				return errors.Wrap(err, "could not execute payload")
+			}
+		}
 	}
 
 	if err := s.pruneCanonicalAttsFromPool(ctx, blockRoot, signed); err != nil {
@@ -251,32 +392,33 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 }
 
 func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlock,
-	blockRoots [][32]byte) ([]*ethpb.Checkpoint, []*ethpb.Checkpoint, error) {
+	blockRoots [][32]byte) ([]*ethpb.Checkpoint, []*ethpb.Checkpoint, []bool, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockBatch")
 	defer span.End()
 
 	if len(blks) == 0 || len(blockRoots) == 0 {
-		return nil, nil, errors.New("no blocks provided")
+		return nil, nil, nil, errors.New("no blocks provided")
 	}
 	if err := helpers.BeaconBlockIsNil(blks[0]); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	b := blks[0].Block()
 
 	// Retrieve incoming block's pre state.
 	if err := s.verifyBlkPreState(ctx, b); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	preState, err := s.cfg.StateGen.StateByRootInitialSync(ctx, bytesutil.ToBytes32(b.ParentRoot()))
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	if preState == nil || preState.IsNil() {
-		return nil, nil, fmt.Errorf("nil pre state for slot %d", b.Slot())
+		return nil, nil, nil, fmt.Errorf("nil pre state for slot %d", b.Slot())
 	}
 
 	jCheckpoints := make([]*ethpb.Checkpoint, len(blks))
 	fCheckpoints := make([]*ethpb.Checkpoint, len(blks))
+	optimistic := make([]bool, len(blks))
 	sigSet := &bls.SignatureBatch{
 		Signatures: [][]byte{},
 		PublicKeys: []bls.PublicKey{},
@@ -285,43 +427,140 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 	var set *bls.SignatureBatch
 	boundaries := make(map[[32]byte]state.BeaconState)
 	for i, b := range blks {
+		preStateCopied := preState.Copy() // TODO_MERGE: Optimize this copy.
 		set, preState, err = transition.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)
 		if err != nil {
-			return nil, nil, err
+			return nil, nil, nil, err
 		}
+
+		// Non merge blocks are never optimistic
+		optimistic[i] = false
+		if preState.Version() == version.Bellatrix {
+			executionEnabled, err := blocks.ExecutionEnabled(preState, b.Block().Body())
+			if err != nil {
+				return nil, nil, nil, errors.Wrap(err, "could not check if execution is enabled")
+			}
+			if executionEnabled {
+				payload, err := b.Block().Body().ExecutionPayload()
+				if err != nil {
+					return nil, nil, nil, errors.Wrap(err, "could not get body execution payload")
+				}
+				status, err := s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload)
+				if err != nil {
+					return nil, nil, nil, err
+				}
+				switch status.Status {
+				case enginev1.PayloadStatus_INVALID, enginev1.PayloadStatus_INVALID_BLOCK_HASH, enginev1.PayloadStatus_INVALID_TERMINAL_BLOCK:
+					// TODO_MERGE walk up the parent chain removing
+					return nil, nil, nil, fmt.Errorf("could not prcess execution payload with status : %v", status.Status)
+				case enginev1.PayloadStatus_SYNCING, enginev1.PayloadStatus_ACCEPTED:
+					candidate, err := s.optimisticCandidateBlock(ctx, b.Block())
+					if err != nil {
+						return nil, nil, nil, errors.Wrap(err, "could not check if block is optimistic candidate")
+					}
+					if !candidate {
+						return nil, nil, nil, errors.New("could not optimistically sync block")
+					}
+					log.WithFields(logrus.Fields{
+						"slot":        b.Block().Slot(),
+						"root":        fmt.Sprintf("%#x", bytesutil.Trunc(blockRoots[i][:])),
+						"payloadHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash)),
+					}).Info("Block is optimistic candidate")
+					optimistic[i] = true
+					break
+				case enginev1.PayloadStatus_VALID:
+				default:
+					return nil, nil, nil, errors.New("unknown payload status")
+				}
+				if !optimistic[i] {
+					mergeBlock, err := blocks.MergeTransitionBlock(preStateCopied, b.Block().Body())
+					if err != nil {
+						return nil, nil, nil, errors.Wrap(err, "could not check if merge block is terminal")
+					}
+					if mergeBlock {
+						if err := s.validateTerminalBlock(ctx, b); err != nil {
+							return nil, nil, nil, err
+						}
+					}
+				}
+
+				headPayload, err := b.Block().Body().ExecutionPayload()
+				if err != nil {
+					return nil, nil, nil, err
+
+				}
+				// TODO_MERGE: Loading the finalized block from DB on per block is not ideal. Finalized block should be cached here
+				finalizedBlock, err := s.cfg.BeaconDB.Block(ctx, bytesutil.ToBytes32(preState.FinalizedCheckpoint().Root))
+				if err != nil {
+					return nil, nil, nil, err
+
+				}
+				finalizedBlockHash := params.BeaconConfig().ZeroHash[:]
+				if finalizedBlock != nil && finalizedBlock.Version() == version.Bellatrix {
+					finalizedPayload, err := finalizedBlock.Block().Body().ExecutionPayload()
+					if err != nil {
+						return nil, nil, nil, err
+
+					}
+					finalizedBlockHash = finalizedPayload.BlockHash
+				}
+
+				fcs := &enginev1.ForkchoiceState{
+					HeadBlockHash:      headPayload.BlockHash,
+					SafeBlockHash:      headPayload.BlockHash,
+					FinalizedBlockHash: finalizedBlockHash,
+				}
+
+				resp, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, nil /* attribute */)
+				if err != nil {
+					return nil, nil, nil, err
+				}
+				switch resp.Status.Status {
+				case enginev1.PayloadStatus_INVALID, enginev1.PayloadStatus_INVALID_BLOCK_HASH, enginev1.PayloadStatus_INVALID_TERMINAL_BLOCK:
+					return nil, nil, nil, fmt.Errorf("could not prcess execution payload with status : %v", resp.Status.Status)
+				case enginev1.PayloadStatus_SYNCING, enginev1.PayloadStatus_ACCEPTED:
+					break
+				case enginev1.PayloadStatus_VALID:
+				default:
+					return nil, nil, nil, errors.Wrap(err, "could not execute payload")
+				}
+			}
+		}
+
 		// Save potential boundary states.
 		if slots.IsEpochStart(preState.Slot()) {
 			boundaries[blockRoots[i]] = preState.Copy()
 			if err := s.handleEpochBoundary(ctx, preState); err != nil {
-				return nil, nil, errors.Wrap(err, "could not handle epoch boundary state")
+				return nil, nil, nil, errors.Wrap(err, "could not handle epoch boundary state")
 			}
 		}
 		jCheckpoints[i] = preState.CurrentJustifiedCheckpoint()
 		fCheckpoints[i] = preState.FinalizedCheckpoint()
+
 		sigSet.Join(set)
 	}
 	verify, err := sigSet.Verify()
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	if !verify {
-		return nil, nil, errors.New("batch block signature verification failed")
+		return nil, nil, nil, errors.New("batch block signature verification failed")
 	}
 	for r, st := range boundaries {
 		if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
-			return nil, nil, err
+			return nil, nil, nil, err
 		}
 	}
 	// Also saves the last post state which to be used as pre state for the next batch.
 	lastB := blks[len(blks)-1]
 	lastBR := blockRoots[len(blockRoots)-1]
 	if err := s.cfg.StateGen.SaveState(ctx, lastBR, preState); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	if err := s.saveHeadNoDB(ctx, lastB, lastBR, preState); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
-	return fCheckpoints, jCheckpoints, nil
+	return fCheckpoints, jCheckpoints, optimistic, nil
 }
 
 // handles a block after the block's batch has been verified, where we can save blocks
@@ -334,10 +573,6 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed block.
 	if err := s.insertBlockToForkChoiceStore(ctx, b, blockRoot, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
-	if err := s.saveSyncedTipsDB(ctx); err != nil {
-		return errors.Wrap(err, "could not save synced tips")
-	}
-
 	if err := s.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{
 		Slot: signed.Block().Slot(),
 		Root: blockRoot[:],
@@ -510,6 +745,88 @@ func (s *Service) pruneCanonicalAttsFromPool(ctx context.Context, r [32]byte, b
 	return nil
 }
 
+// validates terminal block hash in the event of manual overrides before checking for total difficulty.
+//
+// def validate_merge_block(block: BeaconBlock) -> None:
+//    """
+//    Check the parent PoW block of execution payload is a valid terminal PoW block.
+//
+//    Note: Unavailable PoW block(s) may later become available,
+//    and a client software MAY delay a call to ``validate_merge_block``
+//    until the PoW block(s) become available.
+//    """
+//    if TERMINAL_BLOCK_HASH != Hash32():
+//        # If `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
+//        assert compute_epoch_at_slot(block.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
+//        return block.block_hash == TERMINAL_BLOCK_HASH
+//
+//    pow_block = get_pow_block(block.body.execution_payload.parent_hash)
+//    # Check if `pow_block` is available
+//    assert pow_block is not None
+//    pow_parent = get_pow_block(pow_block.parent_hash)
+//    # Check if `pow_parent` is available
+//    assert pow_parent is not None
+//    # Check if `pow_block` is a valid terminal PoW block
+//    assert is_valid_terminal_pow_block(pow_block, pow_parent)
+func (s *Service) validateTerminalBlock(ctx context.Context, b block.SignedBeaconBlock) error {
+	payload, err := b.Block().Body().ExecutionPayload()
+	if err != nil {
+		return err
+	}
+	if bytesutil.ToBytes32(params.BeaconConfig().TerminalBlockHash.Bytes()) != [32]byte{} {
+		// `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
+		if params.BeaconConfig().TerminalBlockHashActivationEpoch > slots.ToEpoch(b.Block().Slot()) {
+			return errors.New("terminal block hash activation epoch not reached")
+		}
+		if !bytes.Equal(payload.ParentHash, params.BeaconConfig().TerminalBlockHash.Bytes()) {
+			return errors.New("parent hash does not match terminal block hash")
+		}
+		return nil
+	}
+	transitionBlk, err := s.cfg.ExecutionEngineCaller.ExecutionBlockByHash(ctx, common.BytesToHash(payload.ParentHash))
+	if err != nil {
+		return errors.Wrap(err, "could not get transition block")
+	}
+	parentTransitionBlk, err := s.cfg.ExecutionEngineCaller.ExecutionBlockByHash(ctx, common.BytesToHash(transitionBlk.ParentHash))
+	if err != nil {
+		return errors.Wrap(err, "could not get transition parent block")
+	}
+	transitionBlkTDBig, err := hexutil.DecodeBig(transitionBlk.TotalDifficulty)
+	if err != nil {
+		return errors.Wrap(err, "could not decode transition total difficulty")
+	}
+	transitionBlkTTD, overflows := uint256.FromBig(transitionBlkTDBig)
+	if overflows {
+		return errors.New("total difficulty overflows")
+	}
+	parentBlkTD, err := hexutil.DecodeBig(parentTransitionBlk.TotalDifficulty)
+	if err != nil {
+		return errors.Wrap(err, "could not decode transition total difficulty")
+	}
+	parentBlkTTD, overflows := uint256.FromBig(parentBlkTD)
+	if overflows {
+		return errors.New("total difficulty overflows")
+	}
+	log.WithFields(logrus.Fields{
+		"slot":                                 b.Block().Slot(),
+		"transitionBlockHash":                  common.BytesToHash(payload.ParentHash).String(),
+		"transitionBlockParentHash":            common.BytesToHash(transitionBlk.ParentHash).String(),
+		"terminalTotalDifficulty":              params.BeaconConfig().TerminalTotalDifficulty,
+		"transitionBlockTotalDifficulty":       transitionBlkTTD,
+		"transitionBlockParentTotalDifficulty": parentBlkTTD,
+	}).Info("Validating terminal block")
+
+	validated, err := validTerminalPowBlock(transitionBlkTTD, parentBlkTTD)
+	if err != nil {
+		return err
+	}
+	if !validated {
+		return errors.New("invalid difficulty for terminal block")
+	}
+
+	return nil
+}
+
 // Saves synced and validated tips to DB.
 func (s *Service) saveSyncedTipsDB(ctx context.Context) error {
 	tips := s.cfg.ForkChoiceStore.SyncedTips()

beacon-chain/blockchain/process_block_test.go

@@ -178,7 +178,7 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	rBlock.Block.ParentRoot = gRoot[:]
 	require.NoError(t, beaconDB.SaveBlock(context.Background(), blks[0]))
 	require.NoError(t, service.cfg.StateGen.SaveState(ctx, blkRoots[0], firstState))
-	_, _, err = service.onBlockBatch(ctx, blks[1:], blkRoots[1:])
+	_, _, _, err = service.onBlockBatch(ctx, blks[1:], blkRoots[1:])
 	require.NoError(t, err)
 }
 

beacon-chain/blockchain/receive_block.go

@@ -77,7 +77,7 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []block.SignedBe
 	defer span.End()
 
 	// Apply state transition on the incoming newly received blockCopy without verifying its BLS contents.
-	fCheckpoints, jCheckpoints, err := s.onBlockBatch(ctx, blocks, blkRoots)
+	fCheckpoints, jCheckpoints, optimistic, err := s.onBlockBatch(ctx, blocks, blkRoots)
 	if err != nil {
 		err := errors.Wrap(err, "could not process block in batch")
 		tracing.AnnotateError(span, err)
@@ -90,6 +90,19 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []block.SignedBe
 			tracing.AnnotateError(span, err)
 			return err
 		}
+		if !optimistic[i] {
+			root, err := b.Block().HashTreeRoot()
+			if err != nil {
+				return err
+			}
+			if err := s.cfg.ForkChoiceStore.UpdateSyncedTipsWithValidRoot(ctx, root); err != nil {
+				return err
+			}
+			if err := s.saveSyncedTipsDB(ctx); err != nil {
+				return errors.Wrap(err, "could not save synced tips")
+			}
+		}
+
 		// Send notification of the processed block to the state feed.
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.BlockProcessed,

beacon-chain/blockchain/service.go

@@ -11,6 +11,8 @@ import (
 
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
+  
+  
 	"github.com/prysmaticlabs/prysm/async/event"
 	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain/store"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
@@ -83,6 +85,7 @@ type config struct {
 	StateGen                *stategen.State
 	SlasherAttestationsFeed *event.Feed
 	WeakSubjectivityCheckpt *ethpb.Checkpoint
+	BlockFetcher            powchain.POWBlockFetcher
 	FinalizedStateAtStartUp state.BeaconState
 	ExecutionEngineCaller   enginev1.Caller
 }

beacon-chain/node/node.go

@@ -119,6 +119,7 @@ func New(cliCtx *cli.Context, opts ...Option) (*BeaconNode, error) {
 	configureEth1Config(cliCtx)
 	configureNetwork(cliCtx)
 	configureInteropConfig(cliCtx)
+	configureExecutionSetting(cliCtx)
 
 	// Initializes any forks here.
 	params.BeaconConfig().InitializeForkSchedule()
@@ -554,6 +555,7 @@ func (b *BeaconNode) registerBlockchainService() error {
 		blockchain.WithDatabase(b.db),
 		blockchain.WithDepositCache(b.depositCache),
 		blockchain.WithChainStartFetcher(web3Service),
+		blockchain.WithExecutionEngineCaller(web3Service.EngineAPIClient()),
 		blockchain.WithAttestationPool(b.attestationPool),
 		blockchain.WithExitPool(b.exitPool),
 		blockchain.WithSlashingPool(b.slashingsPool),
@@ -780,6 +782,7 @@ func (b *BeaconNode) registerRPCService() error {
 		StateGen:                b.stateGen,
 		EnableDebugRPCEndpoints: enableDebugRPCEndpoints,
 		MaxMsgSize:              maxMsgSize,
+		ExecutionEngineCaller:   web3Service.EngineAPIClient(),
 	})
 
 	return b.services.RegisterService(rpcService)

beacon-chain/rpc/BUILD.bazel

@@ -22,6 +22,7 @@ go_library(
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/powchain:go_default_library",
+        "//beacon-chain/powchain/engine-api-client/v1:go_default_library",
         "//beacon-chain/rpc/eth/beacon:go_default_library",
         "//beacon-chain/rpc/eth/debug:go_default_library",
         "//beacon-chain/rpc/eth/events:go_default_library",

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

@@ -15,6 +15,7 @@ go_library(
         "proposer_bellatrix.go",
         "proposer_deposits.go",
         "proposer_eth1data.go",
+        "proposer_execution_payload.go",
         "proposer_phase0.go",
         "proposer_sync_aggregate.go",
         "server.go",
@@ -40,12 +41,14 @@ go_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/operations/attestations:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/synccommittee:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/powchain:go_default_library",
+        "//beacon-chain/powchain/engine-api-client/v1:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/sync:go_default_library",
@@ -71,7 +74,9 @@ go_library(
         "//runtime/version:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ferranbt_fastssz//:go_default_library",
+        "@com_github_holiman_uint256//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
@@ -154,6 +159,8 @@ go_test(
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+        "@org_golang_google_grpc//codes:go_default_library",
+        "@org_golang_google_grpc//status:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
     ],

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

@@ -28,6 +28,11 @@ func (vs *Server) SubmitAggregateSelectionProof(ctx context.Context, req *ethpb.
 		return nil, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
 	}
 
+	// An optimistic validator MUST NOT participate in attestation. (i.e., sign across the DOMAIN_BEACON_ATTESTER, DOMAIN_SELECTION_PROOF or DOMAIN_AGGREGATE_AND_PROOF domains).
+	//if err := vs.optimisticStatus(ctx); err != nil {
+	//	return nil, err
+	//}
+
 	st, err := vs.HeadFetcher.HeadState(ctx)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not determine head state: %v", err)

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

@@ -37,6 +37,11 @@ func (vs *Server) GetAttestationData(ctx context.Context, req *ethpb.Attestation
 		return nil, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
 	}
 
+	// An optimistic validator MUST NOT participate in attestation. (i.e., sign across the DOMAIN_BEACON_ATTESTER, DOMAIN_SELECTION_PROOF or DOMAIN_AGGREGATE_AND_PROOF domains).
+	//if err := vs.optimisticStatus(ctx); err != nil {
+	//	return nil, err
+	//}
+
 	if err := helpers.ValidateAttestationTime(req.Slot, vs.TimeFetcher.GenesisTime(),
 		params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
 		return nil, status.Error(codes.InvalidArgument, fmt.Sprintf("invalid request: %v", err))

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

@@ -26,6 +26,8 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/util"
 	prysmTime "github.com/prysmaticlabs/prysm/time"
 	"github.com/prysmaticlabs/prysm/time/slots"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -169,6 +171,18 @@ func TestGetAttestationData_SyncNotReady(t *testing.T) {
 	assert.ErrorContains(t, "Syncing to latest head", err)
 }
 
+func TestGetAttestationData_Optimistic(t *testing.T) {
+	as := &Server{
+		SyncChecker: &mockSync.Sync{},
+		HeadFetcher: &mock.ChainService{Optimistic: true},
+	}
+	_, err := as.GetAttestationData(context.Background(), &ethpb.AttestationDataRequest{})
+	s, ok := status.FromError(err)
+	require.Equal(t, true, ok)
+	require.DeepEqual(t, codes.Unavailable, s.Code())
+	require.ErrorContains(t, " The node is currently optimistic and cannot serve validators", err)
+}
+
 func TestAttestationDataAtSlot_HandlesFarAwayJustifiedEpoch(t *testing.T) {
 	// Scenario:
 	//
@@ -317,6 +331,7 @@ func TestServer_GetAttestationData_InvalidRequestSlot(t *testing.T) {
 	offset := int64(slot.Mul(params.BeaconConfig().SecondsPerSlot))
 	attesterServer := &Server{
 		SyncChecker: &mockSync.Sync{IsSyncing: false},
+		HeadFetcher: &mock.ChainService{},
 		TimeFetcher: &mock.ChainService{Genesis: time.Now().Add(time.Duration(-1*offset) * time.Second)},
 	}
 

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

@@ -48,6 +48,11 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Altair{Altair: blk}}, nil
 	}
 
+	// 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
+	//}
+
 	blk, err := vs.getBellatrixBeaconBlock(ctx, req)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not fetch Bellatrix beacon block: %v", err)

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

@@ -89,7 +89,7 @@ func (a proposerAtts) filter(ctx context.Context, st state.BeaconState) (propose
 	switch st.Version() {
 	case version.Phase0:
 		attestationProcessor = blocks.ProcessAttestationNoVerifySignature
-	case version.Altair:
+	case version.Altair, version.Bellatrix:
 		// Use a wrapper here, as go needs strong typing for the function signature.
 		attestationProcessor = func(ctx context.Context, st state.BeaconState, attestation *ethpb.Attestation) (state.BeaconState, error) {
 			totalBalance, err := helpers.TotalActiveBalance(st)

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

@@ -5,11 +5,10 @@ import (
 	"fmt"
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition/interop"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
+	"github.com/sirupsen/logrus"
 )
 
 func (vs *Server) getBellatrixBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (*ethpb.BeaconBlockBellatrix, error) {
@@ -18,6 +17,18 @@ func (vs *Server) getBellatrixBeaconBlock(ctx context.Context, req *ethpb.BlockR
 		return nil, err
 	}
 
+	payload, err := vs.getExecutionPayload(ctx, req.Slot)
+	if err != nil {
+		return nil, err
+	}
+
+	log.WithFields(logrus.Fields{
+		"hash":       fmt.Sprintf("%#x", payload.BlockHash),
+		"parentHash": fmt.Sprintf("%#x", payload.ParentHash),
+		"number":     payload.BlockNumber,
+		"txCount":    len(payload.Transactions),
+	}).Info("Received payload")
+
 	blk := &ethpb.BeaconBlockBellatrix{
 		Slot:          altairBlk.Slot,
 		ProposerIndex: altairBlk.ProposerIndex,

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

@@ -0,0 +1,278 @@
+package validator
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/holiman/uint256"
+	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
+	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/runtime/version"
+	"github.com/prysmaticlabs/prysm/time/slots"
+	"github.com/sirupsen/logrus"
+)
+
+// This returns the execution payload of a given slot. The function has full awareness of pre and post merge.
+// Payload is computed given the respected time of merge.
+//
+// Spec code:
+// def prepare_execution_payload(state: BeaconState,
+//                              pow_chain: Dict[Hash32, PowBlock],
+//                              finalized_block_hash: Hash32,
+//                              fee_recipient: ExecutionAddress,
+//                              execution_engine: ExecutionEngine) -> Optional[PayloadId]:
+//    if not is_merge_complete(state):
+//        is_terminal_block_hash_set = TERMINAL_BLOCK_HASH != Hash32()
+//        is_activation_epoch_reached = get_current_epoch(state.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
+//        if is_terminal_block_hash_set and not is_activation_epoch_reached:
+//            # Terminal block hash is set but activation epoch is not yet reached, no prepare payload call is needed
+//            return None
+//
+//        terminal_pow_block = get_terminal_pow_block(pow_chain)
+//        if terminal_pow_block is None:
+//            # Pre-merge, no prepare payload call is needed
+//            return None
+//        # Signify merge via producing on top of the terminal PoW block
+//        parent_hash = terminal_pow_block.block_hash
+//    else:
+//        # Post-merge, normal payload
+//        parent_hash = state.latest_execution_payload_header.block_hash
+//
+//    # Set the forkchoice head and initiate the payload build process
+//    payload_attributes = PayloadAttributes(
+//        timestamp=compute_timestamp_at_slot(state, state.slot),
+//        random=get_randao_mix(state, get_current_epoch(state)),
+//        fee_recipient=fee_recipient,
+//    )
+//    return execution_engine.notify_forkchoice_updated(parent_hash, finalized_block_hash, payload_attributes)
+func (vs *Server) getExecutionPayload(ctx context.Context, slot types.Slot) (*enginev1.ExecutionPayload, error) {
+	// TODO_MERGE: Reuse the same head state as in building phase0 block attestation.
+	st, err := vs.HeadFetcher.HeadState(ctx)
+	if err != nil {
+		return nil, err
+	}
+	st, err = transition.ProcessSlots(ctx, st, slot)
+	if err != nil {
+		return nil, err
+	}
+
+	var parentHash []byte
+	var hasTerminalBlock bool
+	complete, err := blocks.MergeTransitionComplete(st)
+	if err != nil {
+		return nil, err
+	}
+
+	if !complete {
+		if bytesutil.ToBytes32(params.BeaconConfig().TerminalBlockHash.Bytes()) != [32]byte{} {
+			// `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
+			isActivationEpochReached := params.BeaconConfig().TerminalBlockHashActivationEpoch <= slots.ToEpoch(slot)
+			if !isActivationEpochReached {
+				return emptyPayload(), nil
+			}
+		}
+
+		parentHash, hasTerminalBlock, err = vs.getTerminalBlockHash(ctx)
+		if err != nil {
+			return nil, err
+		}
+		if !hasTerminalBlock {
+			// No terminal block signals this is pre merge, empty payload is used.
+			return emptyPayload(), nil
+		}
+		// Terminal block found signals production on top of terminal PoW block.
+	} else {
+		// Post merge, normal payload is used.
+		header, err := st.LatestExecutionPayloadHeader()
+		if err != nil {
+			return nil, err
+		}
+		parentHash = header.BlockHash
+	}
+
+	t, err := slots.ToTime(st.GenesisTime(), slot)
+	if err != nil {
+		return nil, err
+	}
+	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
+	if err != nil {
+		return nil, err
+	}
+
+	finalizedBlock, err := vs.BeaconDB.Block(ctx, bytesutil.ToBytes32(st.FinalizedCheckpoint().Root))
+	if err != nil {
+		return nil, err
+	}
+	finalizedBlockHash := params.BeaconConfig().ZeroHash[:]
+	if finalizedBlock != nil && finalizedBlock.Version() == version.Bellatrix {
+		finalizedPayload, err := finalizedBlock.Block().Body().ExecutionPayload()
+		if err != nil {
+			return nil, err
+		}
+		finalizedBlockHash = finalizedPayload.BlockHash
+	}
+
+	f := &enginev1.ForkchoiceState{
+		HeadBlockHash:      parentHash,
+		SafeBlockHash:      parentHash,
+		FinalizedBlockHash: finalizedBlockHash,
+	}
+	p := &enginev1.PayloadAttributes{
+		Timestamp:             uint64(t.Unix()),
+		Random:                random,
+		SuggestedFeeRecipient: params.BeaconConfig().FeeRecipient.Bytes(),
+	}
+	res, err := vs.ExecutionEngineCaller.ForkchoiceUpdated(ctx, f, p)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not prepare payload")
+	}
+	log.WithFields(logrus.Fields{
+		"status:": res.Status.Status,
+		"hash:":   fmt.Sprintf("%#x", f.HeadBlockHash),
+	}).Info("Successfully called forkchoiceUpdated with attribute")
+
+	if res == nil || res.PayloadId == nil {
+		return nil, errors.New("forkchoice returned nil")
+	}
+
+	log.WithFields(logrus.Fields{
+		"id":   fmt.Sprintf("%#x", &res.PayloadId),
+		"slot": slot,
+		"hash": fmt.Sprintf("%#x", parentHash),
+	}).Info("Received payload ID")
+	var id [8]byte
+	copy(id[:], res.PayloadId[:])
+	return vs.ExecutionEngineCaller.GetPayload(ctx, id)
+}
+
+// This returns the valid terminal block hash with an existence bool value.
+//
+// Spec code:
+// def get_terminal_pow_block(pow_chain: Dict[Hash32, PowBlock]) -> Optional[PowBlock]:
+//    if TERMINAL_BLOCK_HASH != Hash32():
+//        # Terminal block hash override takes precedence over terminal total difficulty
+//        if TERMINAL_BLOCK_HASH in pow_chain:
+//            return pow_chain[TERMINAL_BLOCK_HASH]
+//        else:
+//            return None
+//
+//    return get_pow_block_at_terminal_total_difficulty(pow_chain)
+func (vs *Server) getTerminalBlockHash(ctx context.Context) ([]byte, bool, error) {
+	terminalBlockHash := params.BeaconConfig().TerminalBlockHash
+	// Terminal block hash override takes precedence over terminal total difficult.
+	if params.BeaconConfig().TerminalBlockHash != params.BeaconConfig().ZeroHash {
+		e, _, err := vs.Eth1BlockFetcher.BlockExists(ctx, terminalBlockHash)
+		if err != nil {
+			return nil, false, err
+		}
+		if !e {
+			return nil, false, nil
+		}
+
+		return terminalBlockHash.Bytes(), true, nil
+	}
+
+	return vs.getPowBlockHashAtTerminalTotalDifficulty(ctx)
+}
+
+// This returns the valid terminal block hash based on total difficulty.
+//
+// Spec code:
+// def get_pow_block_at_terminal_total_difficulty(pow_chain: Dict[Hash32, PowBlock]) -> Optional[PowBlock]:
+//    # `pow_chain` abstractly represents all blocks in the PoW chain
+//    for block in pow_chain:
+//        parent = pow_chain[block.parent_hash]
+//        block_reached_ttd = block.total_difficulty >= TERMINAL_TOTAL_DIFFICULTY
+//        parent_reached_ttd = parent.total_difficulty >= TERMINAL_TOTAL_DIFFICULTY
+//        if block_reached_ttd and not parent_reached_ttd:
+//            return block
+//
+//    return None
+func (vs *Server) getPowBlockHashAtTerminalTotalDifficulty(ctx context.Context) ([]byte, bool, error) {
+	ttd := new(big.Int)
+	ttd.SetString(params.BeaconConfig().TerminalTotalDifficulty, 10)
+	terminalTotalDifficulty, overflows := uint256.FromBig(ttd)
+	if overflows {
+		return nil, false, errors.New("could not convert terminal total difficulty to uint256")
+	}
+	blk, err := vs.ExecutionEngineCaller.LatestExecutionBlock(ctx)
+	if err != nil {
+		return nil, false, errors.Wrap(err, "could not get latest execution block")
+	}
+	log.WithFields(logrus.Fields{
+		"number": blk.Number,
+		"hash":   fmt.Sprintf("%#x", blk.Hash),
+		"td":     blk.TotalDifficulty,
+	}).Info("Retrieving latest execution block")
+
+	for {
+		transitionBlkTDBig, err := hexutil.DecodeBig(blk.TotalDifficulty)
+		if err != nil {
+			return nil, false, errors.Wrap(err, "could not decode transition total difficulty")
+		}
+		currentTotalDifficulty, overflows := uint256.FromBig(transitionBlkTDBig)
+		if overflows {
+			return nil, false, errors.New("total difficulty overflowed")
+		}
+		blockReachedTTD := currentTotalDifficulty.Cmp(terminalTotalDifficulty) >= 0
+		parentHash := bytesutil.ToBytes32(blk.ParentHash)
+		if len(blk.ParentHash) == 0 || parentHash == params.BeaconConfig().ZeroHash {
+			return nil, false, nil
+		}
+		parentBlk, err := vs.ExecutionEngineCaller.ExecutionBlockByHash(ctx, parentHash)
+		if err != nil {
+			return nil, false, errors.Wrap(err, "could not get parent execution block")
+		}
+		log.WithFields(logrus.Fields{
+			"number": parentBlk.Number,
+			"hash":   fmt.Sprintf("%#x", parentBlk.Hash),
+			"td":     parentBlk.TotalDifficulty,
+		}).Info("Retrieving parent execution block")
+
+		if blockReachedTTD {
+			parentTDBig, err := hexutil.DecodeBig(parentBlk.TotalDifficulty)
+			if err != nil {
+				return nil, false, errors.Wrap(err, "could not decode transition total difficulty")
+			}
+			parentTotalDifficulty, overflows := uint256.FromBig(parentTDBig)
+			if overflows {
+				return nil, false, errors.New("total difficulty overflowed")
+			}
+			parentReachedTTD := parentTotalDifficulty.Cmp(terminalTotalDifficulty) >= 0
+			if !parentReachedTTD {
+				log.WithFields(logrus.Fields{
+					"number":   blk.Number,
+					"hash":     fmt.Sprintf("%#x", blk.Hash),
+					"td":       blk.TotalDifficulty,
+					"parentTd": parentBlk.TotalDifficulty,
+					"ttd":      terminalTotalDifficulty,
+				}).Info("Retrieved terminal block hash")
+				return blk.Hash, true, nil
+			}
+		}
+		blk = parentBlk
+	}
+}
+
+func emptyPayload() *enginev1.ExecutionPayload {
+	return &enginev1.ExecutionPayload{
+		ParentHash:    make([]byte, fieldparams.RootLength),
+		FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+		StateRoot:     make([]byte, fieldparams.RootLength),
+		ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+		LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
+		Random:        make([]byte, fieldparams.RootLength),
+		BaseFeePerGas: make([]byte, fieldparams.RootLength),
+		BlockHash:     make([]byte, fieldparams.RootLength),
+	}
+}

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

@@ -39,6 +39,8 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 	"github.com/prysmaticlabs/prysm/time/slots"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -2320,6 +2322,27 @@ func TestProposer_GetBeaconBlock_BellatrixEpoch(t *testing.T) {
 	assert.DeepEqual(t, req.Graffiti, bellatrixBlk.Bellatrix.Body.Graffiti, "Expected block to have correct Graffiti")
 }
 
+func TestProposer_GetBeaconBlock_Optimistic(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	cfg := params.MainnetConfig().Copy()
+	cfg.BellatrixForkEpoch = 2
+	cfg.AltairForkEpoch = 1
+	params.OverrideBeaconConfig(cfg)
+
+	bellatrixSlot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
+	require.NoError(t, err)
+
+	proposerServer := &Server{HeadFetcher: &mock.ChainService{Optimistic: true}}
+	req := &ethpb.BlockRequest{
+		Slot: bellatrixSlot + 1,
+	}
+	_, err = proposerServer.GetBeaconBlock(context.Background(), req)
+	s, ok := status.FromError(err)
+	require.Equal(t, true, ok)
+	require.DeepEqual(t, codes.Unavailable, s.Code())
+	require.ErrorContains(t, " The node is currently optimistic and cannot serve validators", err)
+}
+
 func TestProposer_GetSyncAggregate_OK(t *testing.T) {
 	proposerServer := &Server{
 		SyncChecker:       &mockSync.Sync{IsSyncing: false},

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

@@ -16,12 +16,14 @@ import (
 	opfeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/operation"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/synccommittee"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
+	v1 "github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/beacon-chain/sync"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -62,6 +64,8 @@ type Server struct {
 	PendingDepositsFetcher depositcache.PendingDepositsFetcher
 	OperationNotifier      opfeed.Notifier
 	StateGen               stategen.StateManager
+	ExecutionEngineCaller  v1.EngineCaller
+	BeaconDB               db.HeadAccessDatabase
 }
 
 // WaitForActivation checks if a validator public key exists in the active validator registry of the current

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

@@ -5,6 +5,7 @@ import (
 	"errors"
 
 	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
@@ -237,6 +238,49 @@ func (vs *Server) activationStatus(
 	return activeValidatorExists, statusResponses, nil
 }
 
+// optimisticStatus returns an error if the node is currently optimistic with respect to head.
+// by definition, an optimistic node is not a full node. It is unable to produce blocks,
+// since an execution engine cannot produce a payload upon an unknown parent.
+// It cannot faithfully attest to the head block of the chain, since it has not fully verified that block.
+//
+// Spec:
+// https://github.com/ethereum/consensus-specs/blob/dev/sync/optimistic.md
+func (vs *Server) optimisticStatus(ctx context.Context) error {
+	blk, err := vs.HeadFetcher.HeadBlock(ctx)
+	if err != nil {
+		return err
+	}
+	if slots.ToEpoch(blk.Block().Slot()) < params.BeaconConfig().BellatrixForkEpoch {
+		return nil
+	}
+	st, err := vs.HeadFetcher.HeadState(ctx)
+	if err != nil {
+		return err
+	}
+	enabled, err := blocks.ExecutionEnabled(st, blk.Block().Body())
+	if err != nil {
+		return err
+	}
+	if !enabled {
+		return nil
+	}
+
+	optimistic, err := vs.HeadFetcher.IsOptimistic(ctx)
+	if err != nil {
+		return status.Errorf(codes.Internal, "Could not determine if the node is a optimistic node: %v", err)
+	}
+	if !optimistic {
+		return nil
+	}
+
+	root, err := vs.HeadFetcher.HeadRoot(ctx)
+	if err != nil {
+		return status.Errorf(codes.Internal, "Could not get head root: %v", err)
+	}
+	return status.Errorf(codes.Unavailable, "The node is currently optimistic and cannot serve validators. Head root: %#x", root)
+
+}
+
 // validatorStatus searches for the requested validator's state and deposit to retrieve its inclusion estimate. Also returns the validators index.
 func (vs *Server) validatorStatus(
 	ctx context.Context,

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

@@ -27,6 +27,8 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 	"github.com/prysmaticlabs/prysm/time/slots"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -582,6 +584,18 @@ func TestActivationStatus_OK(t *testing.T) {
 	}
 }
 
+func TestOptimisticStatus(t *testing.T) {
+	server := &Server{HeadFetcher: &mockChain.ChainService{}}
+	err := server.optimisticStatus(context.Background())
+	require.NoError(t, err)
+	server = &Server{HeadFetcher: &mockChain.ChainService{Optimistic: true}}
+	err = server.optimisticStatus(context.Background())
+	s, ok := status.FromError(err)
+	require.Equal(t, true, ok)
+	require.DeepEqual(t, codes.Unavailable, s.Code())
+	require.ErrorContains(t, " The node is currently optimistic and cannot serve validators", err)
+}
+
 func TestValidatorStatus_CorrectActivationQueue(t *testing.T) {
 	ctx := context.Background()
 

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

@@ -22,6 +22,12 @@ import (
 func (vs *Server) GetSyncMessageBlockRoot(
 	ctx context.Context, _ *emptypb.Empty,
 ) (*ethpb.SyncMessageBlockRootResponse, error) {
+	// An optimistic validator MUST NOT participate in sync committees
+	// (i.e., sign across the DOMAIN_SYNC_COMMITTEE, DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF or DOMAIN_CONTRIBUTION_AND_PROOF domains).
+	//if err := vs.optimisticStatus(ctx); err != nil {
+	//	return nil, err
+	//}
+
 	r, err := vs.HeadFetcher.HeadRoot(ctx)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not retrieve head root: %v", err)
@@ -81,6 +87,12 @@ func (vs *Server) GetSyncSubcommitteeIndex(
 func (vs *Server) GetSyncCommitteeContribution(
 	ctx context.Context, req *ethpb.SyncCommitteeContributionRequest,
 ) (*ethpb.SyncCommitteeContribution, error) {
+	// An optimistic validator MUST NOT participate in sync committees
+	// (i.e., sign across the DOMAIN_SYNC_COMMITTEE, DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF or DOMAIN_CONTRIBUTION_AND_PROOF domains).
+	//if err := vs.optimisticStatus(ctx); err != nil {
+	//	return nil, err
+	//}
+
 	msgs, err := vs.SyncCommitteePool.SyncCommitteeMessages(req.Slot)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not get sync subcommittee messages: %v", err)

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

@@ -18,6 +18,8 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/types/known/emptypb"
 )
 
@@ -31,6 +33,17 @@ func TestGetSyncMessageBlockRoot_OK(t *testing.T) {
 	require.DeepEqual(t, r, res.Root)
 }
 
+func TestGetSyncMessageBlockRoot_Optimistic(t *testing.T) {
+	server := &Server{
+		HeadFetcher: &mock.ChainService{Optimistic: true},
+	}
+	_, err := server.GetSyncMessageBlockRoot(context.Background(), &emptypb.Empty{})
+	s, ok := status.FromError(err)
+	require.Equal(t, true, ok)
+	require.DeepEqual(t, codes.Unavailable, s.Code())
+	require.ErrorContains(t, " The node is currently optimistic and cannot serve validators", err)
+}
+
 func TestSubmitSyncMessage_OK(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateAltair(t, 10)
 	server := &Server{

beacon-chain/rpc/service.go

@@ -26,6 +26,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
+	v1 "github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/eth/beacon"
 	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/eth/debug"
 	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/eth/events"
@@ -108,6 +109,7 @@ type Config struct {
 	OperationNotifier       opfeed.Notifier
 	StateGen                *stategen.State
 	MaxMsgSize              int
+	ExecutionEngineCaller   v1.EngineCaller
 }
 
 // NewService instantiates a new RPC service instance that will
@@ -192,6 +194,8 @@ func (s *Service) Start() {
 		SlashingsPool:          s.cfg.SlashingsPool,
 		StateGen:               s.cfg.StateGen,
 		SyncCommitteePool:      s.cfg.SyncCommitteeObjectPool,
+		ExecutionEngineCaller:  s.cfg.ExecutionEngineCaller,
+		BeaconDB:               s.cfg.BeaconDB,
 	}
 	validatorServerV1 := &validator.Server{
 		HeadFetcher:      s.cfg.HeadFetcher,

beacon-chain/sync/pending_blocks_queue.go

@@ -151,7 +151,8 @@ func (s *Service) processPendingBlocks(ctx context.Context) error {
 				continue
 			}
 
-			if err := s.validateBeaconBlock(ctx, b, blkRoot); err != nil {
+			genesisTime := uint64(s.cfg.chain.GenesisTime().Unix())
+			if err := s.validateBeaconBlock(ctx, b, blkRoot, genesisTime); err != nil {
 				log.Debugf("Could not validate block from slot %d: %v", b.Block().Slot(), err)
 				s.setBadBlock(ctx, blkRoot)
 				tracing.AnnotateError(span, err)

beacon-chain/sync/validate_aggregate_proof.go

@@ -41,6 +41,16 @@ func (s *Service) validateAggregateAndProof(ctx context.Context, pid peer.ID, ms
 		return pubsub.ValidationIgnore, nil
 	}
 
+	// We should not attempt to process this message if the node is running in optimistic mode.
+	// We just ignore in p2p so that the peer is not penalized.
+	status, err := s.cfg.chain.IsOptimistic(ctx)
+	if err != nil {
+		return pubsub.ValidationReject, err
+	}
+	if status {
+		return pubsub.ValidationIgnore, nil
+	}
+
 	raw, err := s.decodePubsubMessage(msg)
 	if err != nil {
 		tracing.AnnotateError(span, err)

beacon-chain/sync/validate_aggregate_proof_test.go

@@ -686,3 +686,35 @@ func TestValidateAggregateAndProof_RejectWhenAttEpochDoesntEqualTargetEpoch(t *t
 	assert.NotNil(t, err)
 	assert.Equal(t, pubsub.ValidationReject, res)
 }
+
+func TestValidateAggregateAndProof_Optimistic(t *testing.T) {
+	p := p2ptest.NewTestP2P(t)
+	ctx := context.Background()
+
+	exit, s := setupValidExit(t)
+
+	r := &Service{
+		cfg: &config{
+			p2p: p,
+			chain: &mock.ChainService{
+				State:      s,
+				Optimistic: true,
+			},
+			initialSync: &mockSync.Sync{IsSyncing: false},
+		},
+	}
+	buf := new(bytes.Buffer)
+	_, err := p.Encoding().EncodeGossip(buf, exit)
+	require.NoError(t, err)
+	topic := p2p.GossipTypeMapping[reflect.TypeOf(exit)]
+	m := &pubsub.Message{
+		Message: &pubsubpb.Message{
+			Data:  buf.Bytes(),
+			Topic: &topic,
+		},
+	}
+	res, err := r.validateAggregateAndProof(ctx, "", m)
+	assert.NoError(t, err)
+	valid := res == pubsub.ValidationIgnore
+	assert.Equal(t, true, valid, "Validation should have ignored the message")
+}

beacon-chain/sync/validate_attester_slashing.go

@@ -26,6 +26,16 @@ func (s *Service) validateAttesterSlashing(ctx context.Context, pid peer.ID, msg
 		return pubsub.ValidationIgnore, nil
 	}
 
+	// We should not attempt to process this message if the node is running in optimistic mode.
+	// We just ignore in p2p so that the peer is not penalized.
+	status, err := s.cfg.chain.IsOptimistic(ctx)
+	if err != nil {
+		return pubsub.ValidationReject, err
+	}
+	if status {
+		return pubsub.ValidationIgnore, nil
+	}
+
 	ctx, span := trace.StartSpan(ctx, "sync.validateAttesterSlashing")
 	defer span.End()
 

beacon-chain/sync/validate_attester_slashing_test.go

@@ -293,3 +293,34 @@ func TestSeenAttesterSlashingIndices(t *testing.T) {
 		assert.Equal(t, tc.seen, r.hasSeenAttesterSlashingIndices(tc.checkIndices1, tc.checkIndices2))
 	}
 }
+
+func TestValidateAttesterSlashing_Optimistic(t *testing.T) {
+	p := p2ptest.NewTestP2P(t)
+	ctx := context.Background()
+
+	slashing, s := setupValidAttesterSlashing(t)
+
+	r := &Service{
+		cfg: &config{
+			p2p:         p,
+			chain:       &mock.ChainService{State: s, Optimistic: true},
+			initialSync: &mockSync.Sync{IsSyncing: false},
+		},
+	}
+
+	buf := new(bytes.Buffer)
+	_, err := p.Encoding().EncodeGossip(buf, slashing)
+	require.NoError(t, err)
+
+	topic := p2p.GossipTypeMapping[reflect.TypeOf(slashing)]
+	msg := &pubsub.Message{
+		Message: &pubsubpb.Message{
+			Data:  buf.Bytes(),
+			Topic: &topic,
+		},
+	}
+	res, err := r.validateAttesterSlashing(ctx, "foobar", msg)
+	assert.NoError(t, err)
+	valid := res == pubsub.ValidationIgnore
+	assert.Equal(t, true, valid, "Should have ignore this message")
+}

beacon-chain/sync/validate_beacon_attestation.go

@@ -40,6 +40,17 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 	if s.cfg.initialSync.Syncing() {
 		return pubsub.ValidationIgnore, nil
 	}
+
+	// We should not attempt to process this message if the node is running in optimistic mode.
+	// We just ignore in p2p so that the peer is not penalized.
+	status, err := s.cfg.chain.IsOptimistic(ctx)
+	if err != nil {
+		return pubsub.ValidationReject, err
+	}
+	if status {
+		return pubsub.ValidationIgnore, nil
+	}
+
 	ctx, span := trace.StartSpan(ctx, "sync.validateCommitteeIndexBeaconAttestation")
 	defer span.End()
 

beacon-chain/sync/validate_beacon_attestation_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"reflect"
 	"testing"
 	"time"
 
@@ -14,6 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
 	dbtest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	p2ptest "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing"
 	mockSync "github.com/prysmaticlabs/prysm/beacon-chain/sync/initial-sync/testing"
 	lruwrpr "github.com/prysmaticlabs/prysm/cache/lru"
@@ -22,6 +24,7 @@ import (
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 )
@@ -298,3 +301,34 @@ func TestService_validateCommitteeIndexBeaconAttestation(t *testing.T) {
 		})
 	}
 }
+
+func TestServiceValidateCommitteeIndexBeaconAttestation_Optimistic(t *testing.T) {
+	p := p2ptest.NewTestP2P(t)
+	ctx := context.Background()
+
+	slashing, s := setupValidAttesterSlashing(t)
+
+	r := &Service{
+		cfg: &config{
+			p2p:         p,
+			chain:       &mockChain.ChainService{State: s, Optimistic: true},
+			initialSync: &mockSync.Sync{IsSyncing: false},
+		},
+	}
+
+	buf := new(bytes.Buffer)
+	_, err := p.Encoding().EncodeGossip(buf, slashing)
+	require.NoError(t, err)
+
+	topic := p2p.GossipTypeMapping[reflect.TypeOf(slashing)]
+	msg := &pubsub.Message{
+		Message: &pubsubpb.Message{
+			Data:  buf.Bytes(),
+			Topic: &topic,
+		},
+	}
+	res, err := r.validateCommitteeIndexBeaconAttestation(ctx, "foobar", msg)
+	assert.NoError(t, err)
+	valid := res == pubsub.ValidationIgnore
+	assert.Equal(t, true, valid, "Should have ignore this message")
+}

beacon-chain/sync/validate_beacon_blocks.go

@@ -161,7 +161,7 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 		return pubsub.ValidationIgnore, errors.Errorf("unknown parent for block with slot %d and parent root %#x", blk.Block().Slot(), blk.Block().ParentRoot())
 	}
 
-	if err := s.validateBeaconBlock(ctx, blk, blockRoot); err != nil {
+	if err := s.validateBeaconBlock(ctx, blk, blockRoot, genesisTime); err != nil {
 		return pubsub.ValidationReject, err
 	}
 
@@ -181,7 +181,7 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 	return pubsub.ValidationAccept, nil
 }
 
-func (s *Service) validateBeaconBlock(ctx context.Context, blk block.SignedBeaconBlock, blockRoot [32]byte) error {
+func (s *Service) validateBeaconBlock(ctx context.Context, blk block.SignedBeaconBlock, blockRoot [32]byte, genesisTime uint64) error {
 	ctx, span := trace.StartSpan(ctx, "sync.validateBeaconBlock")
 	defer span.End()
 

beacon-chain/sync/validate_proposer_slashing.go

@@ -26,6 +26,16 @@ func (s *Service) validateProposerSlashing(ctx context.Context, pid peer.ID, msg
 		return pubsub.ValidationIgnore, nil
 	}
 
+	// We should not attempt to process this message if the node is running in optimistic mode.
+	// We just ignore in p2p so that the peer is not penalized.
+	status, err := s.cfg.chain.IsOptimistic(ctx)
+	if err != nil {
+		return pubsub.ValidationReject, err
+	}
+	if status {
+		return pubsub.ValidationIgnore, nil
+	}
+
 	ctx, span := trace.StartSpan(ctx, "sync.validateProposerSlashing")
 	defer span.End()
 

beacon-chain/sync/validate_proposer_slashing_test.go

@@ -209,3 +209,33 @@ func TestValidateProposerSlashing_Syncing(t *testing.T) {
 	valid := res == pubsub.ValidationAccept
 	assert.Equal(t, false, valid, "Did not fail validation")
 }
+
+func TestValidateProposerSlashing_Optimistic(t *testing.T) {
+	p := p2ptest.NewTestP2P(t)
+	ctx := context.Background()
+
+	slashing, s := setupValidProposerSlashing(t)
+
+	r := &Service{
+		cfg: &config{
+			p2p:         p,
+			chain:       &mock.ChainService{State: s, Optimistic: true},
+			initialSync: &mockSync.Sync{IsSyncing: false},
+		},
+	}
+
+	buf := new(bytes.Buffer)
+	_, err := p.Encoding().EncodeGossip(buf, slashing)
+	require.NoError(t, err)
+	topic := p2p.GossipTypeMapping[reflect.TypeOf(slashing)]
+	m := &pubsub.Message{
+		Message: &pubsubpb.Message{
+			Data:  buf.Bytes(),
+			Topic: &topic,
+		},
+	}
+	res, err := r.validateProposerSlashing(ctx, "", m)
+	assert.NoError(t, err)
+	valid := res == pubsub.ValidationIgnore
+	assert.Equal(t, true, valid, "Did not ignore the message")
+}

beacon-chain/sync/validate_sync_committee_message.go

@@ -57,6 +57,17 @@ func (s *Service) validateSyncCommitteeMessage(
 	if s.cfg.initialSync.Syncing() {
 		return pubsub.ValidationIgnore, nil
 	}
+
+	// We should not attempt to process this message if the node is running in optimistic mode.
+	// We just ignore in p2p so that the peer is not penalized.
+	status, err := s.cfg.chain.IsOptimistic(ctx)
+	if err != nil {
+		return pubsub.ValidationReject, err
+	}
+	if status {
+		return pubsub.ValidationIgnore, nil
+	}
+
 	if msg.Topic == nil {
 		return pubsub.ValidationReject, errInvalidTopic
 	}

beacon-chain/sync/validate_sync_committee_message_test.go

@@ -1,6 +1,7 @@
 package sync
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"reflect"
@@ -561,3 +562,34 @@ func Test_ignoreEmptyCommittee(t *testing.T) {
 		})
 	}
 }
+
+func TestValidateSyncCommitteeMessage_Optimistic(t *testing.T) {
+	p := mockp2p.NewTestP2P(t)
+	ctx := context.Background()
+
+	slashing, s := setupValidAttesterSlashing(t)
+
+	r := &Service{
+		cfg: &config{
+			p2p:         p,
+			chain:       &mockChain.ChainService{State: s, Optimistic: true},
+			initialSync: &mockSync.Sync{IsSyncing: false},
+		},
+	}
+
+	buf := new(bytes.Buffer)
+	_, err := p.Encoding().EncodeGossip(buf, slashing)
+	require.NoError(t, err)
+
+	topic := p2p.GossipTypeMapping[reflect.TypeOf(slashing)]
+	msg := &pubsub.Message{
+		Message: &pubsub_pb.Message{
+			Data:  buf.Bytes(),
+			Topic: &topic,
+		},
+	}
+	res, err := r.validateCommitteeIndexBeaconAttestation(ctx, "foobar", msg)
+	assert.NoError(t, err)
+	valid := res == pubsub.ValidationIgnore
+	assert.Equal(t, true, valid, "Should have ignore this message")
+}

beacon-chain/sync/validate_sync_contribution_proof.go

@@ -52,6 +52,17 @@ func (s *Service) validateSyncContributionAndProof(ctx context.Context, pid peer
 	if s.cfg.initialSync.Syncing() {
 		return pubsub.ValidationIgnore, nil
 	}
+
+	// We should not attempt to process this message if the node is running in optimistic mode.
+	// We just ignore in p2p so that the peer is not penalized.
+	status, err := s.cfg.chain.IsOptimistic(ctx)
+	if err != nil {
+		return pubsub.ValidationReject, err
+	}
+	if status {
+		return pubsub.ValidationIgnore, nil
+	}
+
 	m, err := s.readSyncContributionMessage(msg)
 	if err != nil {
 		tracing.AnnotateError(span, err)

beacon-chain/sync/validate_sync_contribution_proof_test.go

@@ -1,8 +1,10 @@
 package sync
 
 import (
+	"bytes"
 	"context"
 	"fmt"
+	"reflect"
 	"testing"
 	"time"
 
@@ -890,7 +892,7 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) {
 	}
 }
 
-func TestService_ValidateSyncContributionAndProof_Broadcast(t *testing.T) {
+func TestValidateSyncContributionAndProof(t *testing.T) {
 	ctx := context.Background()
 	db := testingDB.SetupDB(t)
 	headRoot, keys := fillUpBlocksAndState(ctx, t, db)
@@ -1026,6 +1028,37 @@ func TestService_ValidateSyncContributionAndProof_Broadcast(t *testing.T) {
 	}
 }
 
+func TestValidateSyncContributionAndProof_Optimistic(t *testing.T) {
+	p := mockp2p.NewTestP2P(t)
+	ctx := context.Background()
+
+	slashing, s := setupValidAttesterSlashing(t)
+
+	r := &Service{
+		cfg: &config{
+			p2p:         p,
+			chain:       &mockChain.ChainService{State: s, Optimistic: true},
+			initialSync: &mockSync.Sync{IsSyncing: false},
+		},
+	}
+
+	buf := new(bytes.Buffer)
+	_, err := p.Encoding().EncodeGossip(buf, slashing)
+	require.NoError(t, err)
+
+	topic := p2p.GossipTypeMapping[reflect.TypeOf(slashing)]
+	msg := &pubsub.Message{
+		Message: &pubsub_pb.Message{
+			Data:  buf.Bytes(),
+			Topic: &topic,
+		},
+	}
+	res, err := r.validateCommitteeIndexBeaconAttestation(ctx, "foobar", msg)
+	assert.NoError(t, err)
+	valid := res == pubsub.ValidationIgnore
+	assert.Equal(t, true, valid, "Should have ignore this message")
+}
+
 func fillUpBlocksAndState(ctx context.Context, t *testing.T, beaconDB db.Database) ([32]byte, []bls.SecretKey) {
 	gs, keys := util.DeterministicGenesisStateAltair(t, 64)
 	sCom, err := altair.NextSyncCommittee(ctx, gs)

beacon-chain/sync/validate_voluntary_exit.go

@@ -29,6 +29,16 @@ func (s *Service) validateVoluntaryExit(ctx context.Context, pid peer.ID, msg *p
 		return pubsub.ValidationIgnore, nil
 	}
 
+	// We should not attempt to process this message if the node is running in optimistic mode.
+	// We just ignore in p2p so that the peer is not penalized.
+	status, err := s.cfg.chain.IsOptimistic(ctx)
+	if err != nil {
+		return pubsub.ValidationReject, err
+	}
+	if status {
+		return pubsub.ValidationIgnore, nil
+	}
+
 	ctx, span := trace.StartSpan(ctx, "sync.validateVoluntaryExit")
 	defer span.End()
 

beacon-chain/sync/validate_voluntary_exit_test.go

@@ -195,3 +195,35 @@ func TestValidateVoluntaryExit_ValidExit_Syncing(t *testing.T) {
 	valid := res == pubsub.ValidationAccept
 	assert.Equal(t, false, valid, "Validation should have failed")
 }
+
+func TestValidateVoluntaryExit_Optimistic(t *testing.T) {
+	p := p2ptest.NewTestP2P(t)
+	ctx := context.Background()
+
+	exit, s := setupValidExit(t)
+
+	r := &Service{
+		cfg: &config{
+			p2p: p,
+			chain: &mock.ChainService{
+				State:      s,
+				Optimistic: true,
+			},
+			initialSync: &mockSync.Sync{IsSyncing: false},
+		},
+	}
+	buf := new(bytes.Buffer)
+	_, err := p.Encoding().EncodeGossip(buf, exit)
+	require.NoError(t, err)
+	topic := p2p.GossipTypeMapping[reflect.TypeOf(exit)]
+	m := &pubsub.Message{
+		Message: &pubsubpb.Message{
+			Data:  buf.Bytes(),
+			Topic: &topic,
+		},
+	}
+	res, err := r.validateVoluntaryExit(ctx, "", m)
+	assert.NoError(t, err)
+	valid := res == pubsub.ValidationIgnore
+	assert.Equal(t, true, valid, "Validation should have ignored the message")
+}

config/features/config.go

@@ -37,6 +37,7 @@ const disabledFeatureFlag = "Disabled feature flag"
 type Flags struct {
 	// Testnet Flags.
 	PyrmontTestnet bool // PyrmontTestnet defines the flag through which we can enable the node to run on the Pyrmont testnet.
+	KilnTestnet    bool // KilnTestnet defines the flag through which we can enable node to run on the merge testnet.
 
 	// Feature related flags.
 	RemoteSlasherProtection             bool // RemoteSlasherProtection utilizes a beacon node with --slasher mode for validator slashing protection.
@@ -130,6 +131,11 @@ func configureTestnet(ctx *cli.Context, cfg *Flags) {
 		log.Warn("Running on the Prater Testnet")
 		params.UsePraterConfig()
 		params.UsePraterNetworkConfig()
+	} else if ctx.Bool(KilnTestnet.Name) {
+		log.Warn("Running on the Kiln(merge) Testnet")
+		params.UseMergeTestConfig()
+		params.UseMergeTestNetworkConfig()
+		cfg.KilnTestnet = true
 	} else {
 		log.Warn("Running on Ethereum Consensus Mainnet")
 		params.UseMainnetConfig()

config/features/flags.go

@@ -17,6 +17,11 @@ var (
 		Name:  "prater",
 		Usage: "Run Prysm configured for the Prater test network",
 	}
+	// KilnTestnet flag for the multiclient Ethereum consensus testnet.
+	KilnTestnet = &cli.BoolFlag{
+		Name:  "kiln-testnet",
+		Usage: "Run Prysm configured for the kiln test network",
+	}
 	// Mainnet flag for easier tooling, no-op
 	Mainnet = &cli.BoolFlag{
 		Value: true,
@@ -153,6 +158,7 @@ var ValidatorFlags = append(deprecatedFlags, []cli.Flag{
 	disableAttestingHistoryDBCache,
 	PyrmontTestnet,
 	PraterTestnet,
+	KilnTestnet,
 	Mainnet,
 	dynamicKeyReloadDebounceInterval,
 	attestTimely,
@@ -172,6 +178,7 @@ var BeaconChainFlags = append(deprecatedFlags, []cli.Flag{
 	disableGRPCConnectionLogging,
 	PyrmontTestnet,
 	PraterTestnet,
+	KilnTestnet,
 	Mainnet,
 	enablePeerScorer,
 	enableLargerGossipHistory,

config/params/BUILD.bazel

@@ -12,6 +12,7 @@ go_library(
         "minimal_config.go",
         "network_config.go",
         "testnet_e2e_config.go",
+        "testnet_kiln_config.go",
         "testnet_prater_config.go",
         "testnet_pyrmont_config.go",
         "testutils.go",

config/params/testnet_kiln_config.go

@@ -0,0 +1,22 @@
+package params
+
+// UseMergeTestNetworkConfig uses the Merge specific
+// network config.
+func UseMergeTestNetworkConfig() {
+	cfg := BeaconNetworkConfig().Copy()
+	cfg.ContractDeploymentBlock = 0
+	cfg.BootstrapNodes = []string{}
+	OverrideBeaconNetworkConfig(cfg)
+}
+
+// UseMergeTestConfig sets the main beacon chain
+// config for Merge testnet.
+func UseMergeTestConfig() {
+	beaconConfig = KilnTestnetConfig()
+}
+
+// KilnTestnetConfig defines the config for the Kiln testnet.
+func KilnTestnetConfig() *BeaconChainConfig {
+	cfg := MainnetConfig().Copy()
+	return cfg
+}

deps.bzl

@@ -659,8 +659,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_deckarep_golang_set",
         importpath = "github.com/deckarep/golang-set",
-        sum = "h1:SCQV0S6gTtp6itiFrTqI+pfmJ4LN85S1YzhDf9rTHJQ=",
-        version = "v1.7.1",
+        sum = "h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4=",
+        version = "v1.8.0",
     )
 
     go_repository(
@@ -825,8 +825,9 @@ def prysm_deps():
         importpath = "github.com/ethereum/go-ethereum",
         patch_args = ["-p1"],
         patches = ["//third_party:com_github_ethereum_go_ethereum_secp256k1.patch"],
-        sum = "h1:DEYFP9zk+Gruf3ae1JOJVhNmxK28ee+sMELPLgYTXpA=",
-        version = "v1.10.13",
+        replace = "github.com/MariusVanDerWijden/go-ethereum",
+        sum = "h1:nZkWdyuB0ehjFrXFx3HLfLF8e6F9oS/32MRhiT5zHdk=",
+        version = "v1.8.22-0.20220214112821-d40107742729",
     )
 
     go_repository(

go.mod

@@ -10,7 +10,7 @@ require (
 	github.com/dgraph-io/ristretto v0.0.4-0.20210318174700-74754f61e018
 	github.com/dustin/go-humanize v1.0.0
 	github.com/emicklei/dot v0.11.0
-	github.com/ethereum/go-ethereum v1.10.13
+	github.com/ethereum/go-ethereum v1.10.15
 	github.com/ferranbt/fastssz v0.0.0-20210905181407-59cf6761a7d5
 	github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5
 	github.com/fsnotify/fsnotify v1.4.9
@@ -30,6 +30,7 @@ require (
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.0.1
 	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d
 	github.com/herumi/bls-eth-go-binary v0.0.0-20210917013441-d37c07cfda4e
+	github.com/holiman/uint256 v1.2.0
 	github.com/ianlancetaylor/cgosymbolizer v0.0.0-20200424224625-be1b05b0b279
 	github.com/ipfs/go-log/v2 v2.4.0
 	github.com/joonix/log v0.0.0-20200409080653-9c1d2ceb5f1d
@@ -244,13 +245,11 @@ require (
 	github.com/allegro/bigcache v1.2.1 // indirect
 	github.com/cespare/cp v1.1.1 // indirect
 	github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf // indirect
-	github.com/deckarep/golang-set v1.7.1 // indirect
 	github.com/fatih/color v1.9.0 // indirect
 	github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08 // indirect
 	github.com/go-logr/logr v0.2.1 // indirect
 	github.com/go-ole/go-ole v1.2.5 // indirect
 	github.com/go-playground/validator/v10 v10.10.0
-	github.com/holiman/uint256 v1.2.0
 	github.com/peterh/liner v1.2.0 // indirect
 	github.com/prometheus/tsdb v0.10.0 // indirect
 	github.com/prysmaticlabs/gohashtree v0.0.0-20220208111633-0606f58df32f
@@ -261,6 +260,8 @@ require (
 	k8s.io/utils v0.0.0-20200520001619-278ece378a50 // indirect
 )
 
+replace github.com/ethereum/go-ethereum => github.com/MariusVanDerWijden/go-ethereum v1.8.22-0.20220214112821-d40107742729
+
 replace github.com/json-iterator/go => github.com/prestonvanloon/go v1.1.7-0.20190722034630-4f2e55fcf87b
 
 // See https://github.com/prysmaticlabs/grpc-gateway/issues/2

go.sum

@@ -66,6 +66,8 @@ github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
 github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
+github.com/MariusVanDerWijden/go-ethereum v1.8.22-0.20220214112821-d40107742729 h1:nZkWdyuB0ehjFrXFx3HLfLF8e6F9oS/32MRhiT5zHdk=
+github.com/MariusVanDerWijden/go-ethereum v1.8.22-0.20220214112821-d40107742729/go.mod h1:yDL1pvpRjK/y5f25Cev5ITtywS9XqJAjhjWwm8ZfycI=
 github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ=
 github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
@@ -217,9 +219,8 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/davidlazar/go-crypto v0.0.0-20170701192655-dcfb0a7ac018/go.mod h1:rQYf4tfk5sSwFsnDg3qYaBxSjsD9S8+59vW0dKUgme4=
 github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c h1:pFUpOrbxDR6AkioZ1ySsx5yxlDQZ8stG2b88gTPxgJU=
 github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c/go.mod h1:6UhI8N9EjYm1c2odKpFpAYeR8dsBeM7PtzQhRgxRr9U=
-github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ=
-github.com/deckarep/golang-set v1.7.1 h1:SCQV0S6gTtp6itiFrTqI+pfmJ4LN85S1YzhDf9rTHJQ=
-github.com/deckarep/golang-set v1.7.1/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ=
+github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4=
+github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo=
 github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218=
 github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M=
 github.com/deepmap/oapi-codegen v1.8.2 h1:SegyeYGcdi0jLLrpbCMoJxnUUn8GBXHsvr4rbzjuhfU=
@@ -264,8 +265,6 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/ethereum/go-ethereum v1.10.13 h1:DEYFP9zk+Gruf3ae1JOJVhNmxK28ee+sMELPLgYTXpA=
-github.com/ethereum/go-ethereum v1.10.13/go.mod h1:W3yfrFyL9C1pHcwY5hmRHVDaorTiQxhYBkKyu5mEDHw=
 github.com/evanphx/json-patch v4.2.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s=
@@ -579,7 +578,6 @@ github.com/ipfs/go-log/v2 v2.1.3/go.mod h1:/8d0SH3Su5Ooc31QlL1WysJhvyOTDCjcCZ9Ax
 github.com/ipfs/go-log/v2 v2.3.0/go.mod h1:QqGoj30OTpnKaG/LKTGTxoP2mmQtjVMEnK72gynbe/g=
 github.com/ipfs/go-log/v2 v2.4.0 h1:iR/2o9PGWanVJrBgIH5Ff8mPGOwpqLaPIAFqSnsdlzk=
 github.com/ipfs/go-log/v2 v2.4.0/go.mod h1:nPZnh7Cj7lwS3LpRU5Mwr2ol1c2gXIEXuF6aywqrtmo=
-github.com/jackpal/go-nat-pmp v1.0.2-0.20160603034137-1fa385a6f458/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
 github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
 github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
 github.com/jbenet/go-cienv v0.1.0/go.mod h1:TqNnHUmJgXau0nCzC7kXWeotg3J9W34CUv5Djy1+FlA=