From fda7577be1c93563e691ab4c211bf307fa1f5b44 Mon Sep 17 00:00:00 2001
From: devopsbo3 <69951731+devopsbo3@users.noreply.github.com>
Date: Fri, 10 Nov 2023 12:27:53 -0600
Subject: [PATCH] Revert "eth/catalyst: reset to current header if chain is
 rewound (in dev mode) (#27992)"

This reverts commit f796c8f5602ef4598252b10345b65b52c350bf6b.
---
 eth/catalyst/simulated_beacon.go | 74 +++++++++-----------------------
 1 file changed, 21 insertions(+), 53 deletions(-)

diff --git a/eth/catalyst/simulated_beacon.go b/eth/catalyst/simulated_beacon.go
index daae2a7c0a..dc623d48ea 100644
--- a/eth/catalyst/simulated_beacon.go
+++ b/eth/catalyst/simulated_beacon.go
@@ -18,6 +18,7 @@ package catalyst
 
 import (
 	"errors"
+	"fmt"
 	"sync"
 	"time"
 
@@ -143,27 +144,18 @@ func (c *SimulatedBeacon) sealBlock(withdrawals []*types.Withdrawal) error {
 	feeRecipient := c.feeRecipient
 	c.feeRecipientLock.Unlock()
 
-	// Reset to CurrentBlock in case of the chain was rewound
-	if header := c.eth.BlockChain().CurrentBlock(); c.curForkchoiceState.HeadBlockHash != header.Hash() {
-		finalizedHash := c.finalizedBlockHash(header.Number.Uint64())
-		c.setCurrentState(header.Hash(), *finalizedHash)
-	}
-
 	fcResponse, err := c.engineAPI.ForkchoiceUpdatedV2(c.curForkchoiceState, &engine.PayloadAttributes{
 		Timestamp:             tstamp,
 		SuggestedFeeRecipient: feeRecipient,
 		Withdrawals:           withdrawals,
 	})
 	if err != nil {
-		return err
-	}
-	if fcResponse == engine.STATUS_SYNCING {
-		return errors.New("chain rewind prevented invocation of payload creation")
+		return fmt.Errorf("error calling forkchoice update: %v", err)
 	}
 
 	envelope, err := c.engineAPI.getPayload(*fcResponse.PayloadID, true)
 	if err != nil {
-		return err
+		return fmt.Errorf("error retrieving payload: %v", err)
 	}
 	payload := envelope.ExecutionPayload
 
@@ -171,21 +163,21 @@ func (c *SimulatedBeacon) sealBlock(withdrawals []*types.Withdrawal) error {
 	if payload.Number%devEpochLength == 0 {
 		finalizedHash = payload.BlockHash
 	} else {
-		if fh := c.finalizedBlockHash(payload.Number); fh == nil {
-			return errors.New("chain rewind interrupted calculation of finalized block hash")
-		} else {
-			finalizedHash = *fh
-		}
+		finalizedHash = c.eth.BlockChain().GetBlockByNumber((payload.Number - 1) / devEpochLength * devEpochLength).Hash()
 	}
 
-	// Mark the payload as canon
+	// mark the payload as canon
 	if _, err = c.engineAPI.NewPayloadV2(*payload); err != nil {
-		return err
+		return fmt.Errorf("failed to mark payload as canonical: %v", err)
 	}
-	c.setCurrentState(payload.BlockHash, finalizedHash)
-	// Mark the block containing the payload as canonical
+	c.curForkchoiceState = engine.ForkchoiceStateV1{
+		HeadBlockHash:      payload.BlockHash,
+		SafeBlockHash:      payload.BlockHash,
+		FinalizedBlockHash: finalizedHash,
+	}
+	// mark the block containing the payload as canonical
 	if _, err = c.engineAPI.ForkchoiceUpdatedV2(c.curForkchoiceState, nil); err != nil {
-		return err
+		return fmt.Errorf("failed to mark block as canonical: %v", err)
 	}
 	c.lastBlockTime = payload.Timestamp
 	return nil
@@ -206,18 +198,20 @@ func (c *SimulatedBeacon) loopOnDemand() {
 		case w := <-c.withdrawals.pending:
 			withdrawals := append(c.withdrawals.gatherPending(9), w)
 			if err := c.sealBlock(withdrawals); err != nil {
-				log.Warn("Error performing sealing work", "err", err)
+				log.Error("Error performing sealing-work", "err", err)
+				return
 			}
 		case <-newTxs:
 			withdrawals := c.withdrawals.gatherPending(10)
 			if err := c.sealBlock(withdrawals); err != nil {
-				log.Warn("Error performing sealing work", "err", err)
+				log.Error("Error performing sealing-work", "err", err)
+				return
 			}
 		}
 	}
 }
 
-// loop runs the block production loop for non-zero period configuration
+// loopOnDemand runs the block production loop for non-zero period configuration
 func (c *SimulatedBeacon) loop() {
 	timer := time.NewTimer(0)
 	for {
@@ -227,40 +221,14 @@ func (c *SimulatedBeacon) loop() {
 		case <-timer.C:
 			withdrawals := c.withdrawals.gatherPending(10)
 			if err := c.sealBlock(withdrawals); err != nil {
-				log.Warn("Error performing sealing work", "err", err)
-			} else {
-				timer.Reset(time.Second * time.Duration(c.period))
+				log.Error("Error performing sealing-work", "err", err)
+				return
 			}
+			timer.Reset(time.Second * time.Duration(c.period))
 		}
 	}
 }
 
-// finalizedBlockHash returns the block hash of the finalized block corresponding to the given number
-// or nil if doesn't exist in the chain.
-func (c *SimulatedBeacon) finalizedBlockHash(number uint64) *common.Hash {
-	var finalizedNumber uint64
-	if number%devEpochLength == 0 {
-		finalizedNumber = number
-	} else {
-		finalizedNumber = (number - 1) / devEpochLength * devEpochLength
-	}
-
-	if finalizedBlock := c.eth.BlockChain().GetBlockByNumber(finalizedNumber); finalizedBlock != nil {
-		fh := finalizedBlock.Hash()
-		return &fh
-	}
-	return nil
-}
-
-// setCurrentState sets the current forkchoice state
-func (c *SimulatedBeacon) setCurrentState(headHash, finalizedHash common.Hash) {
-	c.curForkchoiceState = engine.ForkchoiceStateV1{
-		HeadBlockHash:      headHash,
-		SafeBlockHash:      headHash,
-		FinalizedBlockHash: finalizedHash,
-	}
-}
-
 func RegisterSimulatedBeaconAPIs(stack *node.Node, sim *SimulatedBeacon) {
 	stack.RegisterAPIs([]rpc.API{
 		{