changes on forkchoice, persistent execution_payload_states not include

Author: domiwei

cl/clparams/config.go

@@ -543,6 +543,8 @@ type BeaconChainConfig struct {
 	ElectraForkEpoch     uint64            `yaml:"ELECTRA_FORK_EPOCH" spec:"true" json:"ELECTRA_FORK_EPOCH,string"`     // ElectraForkEpoch is used to represent the assigned fork epoch for Electra.
 	FuluForkVersion      ConfigForkVersion `yaml:"FULU_FORK_VERSION" spec:"true" json:"FULU_FORK_VERSION"`              // FuluForkVersion is used to represent the fork version for Fulu.
 	FuluForkEpoch        uint64            `yaml:"FULU_FORK_EPOCH" spec:"true" json:"FULU_FORK_EPOCH,string"`           // FuluForkEpoch is used to represent the assigned fork epoch for Fulu.
+	GloasForkVersion     ConfigForkVersion `yaml:"GLOAS_FORK_VERSION" spec:"true" json:"GLOAS_FORK_VERSION"`            // GloasForkVersion is used to represent the fork version for Gloas.
+	GloasForkEpoch       uint64            `yaml:"GLOAS_FORK_EPOCH" spec:"true" json:"GLOAS_FORK_EPOCH,string"`         // GloasForkEpoch is used to represent the assigned fork epoch for Gloas.
 
 	ForkVersionSchedule map[common.Bytes4]VersionScheduleEntry `json:"-"` // Schedule of fork epochs by version.
 
@@ -694,6 +696,7 @@ func (b *BeaconChainConfig) GetCurrentStateVersion(epoch uint64) StateVersion {
 		b.DenebForkEpoch,
 		b.ElectraForkEpoch,
 		b.FuluForkEpoch,
+		b.GloasForkEpoch,
 	}
 	stateVersion := Phase0Version
 	for _, forkEpoch := range forkEpochList {

cl/clparams/constants.go

@@ -0,0 +1,18 @@
+package clparams
+
+import "math"
+
+const (
+	// non-configurable constants
+	// For Gloas
+	BuilderIndexFlag                   = uint64(1 << 40) // 2^40
+	BuilderIndexSelfBuild              = math.MaxUint64
+	BuilderPaymentThresholdNumerator   = uint64(6)
+	BuilderPaymentThresholdDenominator = uint64(10)
+	PtcSize                            = uint64(512)
+	PayloadTimelyThreshold             = PtcSize / 2 // 256
+
+	AttestationTimelinessIndex  = 0
+	PtcTimelinessIndex          = 1
+	NumBlockTimelinessDeadlines = 2
+)

cl/clparams/global.go

@@ -1,17 +1,5 @@
 package clparams
 
-import "math"
-
-const (
-	// non-configurable constants
-	// For Gloas
-	BuilderIndexFlag                   = uint64(1 << 40) // 2^40
-	BuilderIndexSelfBuild              = math.MaxUint64
-	BuilderPaymentThresholdNumerator   = uint64(6)
-	BuilderPaymentThresholdDenominator = uint64(10)
-	PtcSize                            = uint64(512)
-)
-
 var (
 	globalBeaconConfig *BeaconChainConfig
 	globalCaplinConfig *CaplinConfig

cl/cltypes/epbs_payload.go

@@ -27,6 +27,14 @@ var (
 	_ ssz2.SizedObjectSSZ = (*SignedExecutionPayloadEnvelope)(nil)
 )
 
+type PayloadStatus uint64
+
+const (
+	PayloadStatusPending PayloadStatus = 0
+	PayloadStatusEmpty   PayloadStatus = 1
+	PayloadStatusFull    PayloadStatus = 2
+)
+
 // PayloadAttestationData represents attestation data for a payload.
 type PayloadAttestationData struct {
 	BeaconBlockRoot   common.Hash `json:"beacon_block_root"`

cl/phase1/forkchoice/fork_graph/fork_graph_disk.go

@@ -181,7 +181,9 @@ func (f *forkGraphDisk) isBlockRootTheCurrentState(blockRoot common.Hash) bool {
 }
 
 // Add a new node and edge to the graph
-func (f *forkGraphDisk) AddChainSegment(signedBlock *cltypes.SignedBeaconBlock, fullValidation bool) (*state.CachingBeaconState, ChainSegmentInsertionResult, error) {
+// parentFullState: if non-nil, use this as the starting state instead of looking up from block_states.
+// [Modified in Gloas:EIP7732] Allows passing execution_payload_states when parent is FULL.
+func (f *forkGraphDisk) AddChainSegment(signedBlock *cltypes.SignedBeaconBlock, fullValidation bool, parentFullState *state.CachingBeaconState) (*state.CachingBeaconState, ChainSegmentInsertionResult, error) {
 	block := signedBlock.Block
 	blockRoot, err := block.HashSSZ()
 	if err != nil {
@@ -200,7 +202,10 @@ func (f *forkGraphDisk) AddChainSegment(signedBlock *cltypes.SignedBeaconBlock,
 
 	isBlockRootTheCurrentState := f.isBlockRootTheCurrentState(blockRoot)
 	var newState *state.CachingBeaconState
-	if isBlockRootTheCurrentState {
+	if parentFullState != nil {
+		// [New in Gloas:EIP7732] Use provided parent state (from execution_payload_states)
+		newState = parentFullState
+	} else if isBlockRootTheCurrentState {
 		newState = f.currentState
 	} else {
 		newState, err = f.getState(block.ParentRoot, false, true)
@@ -213,8 +218,8 @@ func (f *forkGraphDisk) AddChainSegment(signedBlock *cltypes.SignedBeaconBlock,
 		log.Debug("AddChainSegment: missing segment", "block", common.Hash(blockRoot), "slot", block.Slot, "parentRoot", block.ParentRoot)
 		return nil, MissingSegment, nil
 	}
-	finalizedBlock, hasFinalized := f.getBlock(newState.FinalizedCheckpoint().Root)
-	parentBlock, hasParentBlock := f.getBlock(block.ParentRoot)
+	finalizedBlock, hasFinalized := f.GetBlock(newState.FinalizedCheckpoint().Root)
+	parentBlock, hasParentBlock := f.GetBlock(block.ParentRoot)
 
 	// Before processing the state: update the newest lightclient update.
 	if block.Version() >= clparams.AltairVersion && hasParentBlock && fullValidation && hasFinalized && f.rcfg.Beacon && !isBlockRootTheCurrentState {
@@ -328,7 +333,7 @@ func (f *forkGraphDisk) GetHeader(blockRoot common.Hash) (*cltypes.BeaconBlockHe
 	return obj.(*cltypes.BeaconBlockHeader), true
 }
 
-func (f *forkGraphDisk) getBlock(blockRoot common.Hash) (*cltypes.SignedBeaconBlock, bool) {
+func (f *forkGraphDisk) GetBlock(blockRoot common.Hash) (*cltypes.SignedBeaconBlock, bool) {
 	obj, has := f.blocks.Load(blockRoot)
 	if !has {
 		return nil, false
@@ -425,7 +430,7 @@ func (f *forkGraphDisk) getState(blockRoot common.Hash, alwaysCopy bool, addChai
 
 	// try and find the point of recconnection
 	for copyReferencedState == nil {
-		block, isSegmentPresent := f.getBlock(currentIteratorRoot)
+		block, isSegmentPresent := f.GetBlock(currentIteratorRoot)
 		if !isSegmentPresent {
 			// check if it is in the header
 			bHeader, ok := f.GetHeader(currentIteratorRoot)

cl/phase1/forkchoice/fork_graph/fork_graph_test.go

@@ -51,20 +51,20 @@ func TestForkGraphInDisk(t *testing.T) {
 	require.NoError(t, utils.DecodeSSZSnappy(anchorState, anchor, int(clparams.Phase0Version)))
 	emitter := beaconevents.NewEventEmitter()
 	graph := NewForkGraphDisk(anchorState, nil, afero.NewMemMapFs(), beacon_router_configuration.RouterConfiguration{}, emitter)
-	_, status, err := graph.AddChainSegment(blockA, true)
+	_, status, err := graph.AddChainSegment(blockA, true, nil)
 	require.NoError(t, err)
 	require.Equal(t, Success, status)
 	// Now make blockC a bad block
 	blockC.Block.ProposerIndex = 81214459 // some invalid thing
-	_, status, err = graph.AddChainSegment(blockC, true)
+	_, status, err = graph.AddChainSegment(blockC, true, nil)
 	require.Error(t, err)
 	require.Equal(t, InvalidBlock, status)
 	// Save current state hash
-	_, status, err = graph.AddChainSegment(blockB, true)
+	_, status, err = graph.AddChainSegment(blockB, true, nil)
 	require.NoError(t, err)
 	require.Equal(t, Success, status)
 	// Try again with same should yield success
-	_, status, err = graph.AddChainSegment(blockB, true)
+	_, status, err = graph.AddChainSegment(blockB, true, nil)
 	require.NoError(t, err)
 	require.Equal(t, PreValidated, status)
 }

cl/phase1/forkchoice/fork_graph/interface.go

@@ -35,8 +35,11 @@ import (
 * to analyze and manipulate the state of the blockchain.
  */
 type ForkGraph interface {
-	AddChainSegment(signedBlock *cltypes.SignedBeaconBlock, fullValidation bool) (*state.CachingBeaconState, ChainSegmentInsertionResult, error)
+	// AddChainSegment processes a new block and returns the post-state.
+	// parentFullState: if non-nil, use this as the starting state (for GLOAS when parent is FULL).
+	AddChainSegment(signedBlock *cltypes.SignedBeaconBlock, fullValidation bool, parentFullState *state.CachingBeaconState) (*state.CachingBeaconState, ChainSegmentInsertionResult, error)
 	GetHeader(blockRoot common.Hash) (*cltypes.BeaconBlockHeader, bool)
+	GetBlock(blockRoot common.Hash) (*cltypes.SignedBeaconBlock, bool)
 	GetState(blockRoot common.Hash, alwaysCopy bool) (*state.CachingBeaconState, error)
 	GetCurrentJustifiedCheckpoint(blockRoot common.Hash) (solid.Checkpoint, bool)
 	GetFinalizedCheckpoint(blockRoot common.Hash) (solid.Checkpoint, bool)

cl/phase1/forkchoice/forkchoice.go

@@ -17,6 +17,7 @@
 package forkchoice
 
 import (
+	"fmt"
 	"slices"
 	"sort"
 	"sync"
@@ -146,11 +147,15 @@ type ForkChoiceStore struct {
 	ethClock                eth_clock.EthereumClock
 	optimisticStore         optimistic.OptimisticStore
 	probabilisticHeadGetter bool
-}
 
-type LatestMessage struct {
-	Epoch uint64
-	Root  common.Hash
+	// [New in Gloas:EIP7732] Stores post-execution-payload states keyed by beacon block root.
+	// In GLOAS, beacon block and execution payload have separate state transitions.
+	// This stores the state after ProcessExecutionPayloadEnvelope is applied.
+	executionPayloadStates sync.Map // map[common.Hash]*state.CachingBeaconState
+	// [New in Gloas:EIP7732]
+	ptcVote sync.Map // map[common.Hash][clparams.PtcSize]bool
+	// [New in Gloas:EIP7732] Indexed weight store for optimized weight calculation
+	indexedWeightStore *indexedWeightStore
 }
 
 type childrens struct {
@@ -296,6 +301,18 @@ func NewForkChoiceStore(
 
 	f.highestSeen.Store(anchorState.Slot())
 	f.time.Store(anchorState.GenesisTime() + anchorState.BeaconConfig().SecondsPerSlot*anchorState.Slot())
+
+	// [New in Gloas:EIP7732] Initialize anchor root entries with anchor state copy
+	anchorStateCopy, err := anchorState.Copy()
+	if err != nil {
+		return nil, fmt.Errorf("failed to copy anchor state for execution payload states: %w", err)
+	}
+	f.executionPayloadStates.Store(anchorRoot, anchorStateCopy)
+	f.ptcVote.Store(anchorRoot, [clparams.PtcSize]bool{})
+
+	// [New in Gloas:EIP7732] Initialize indexed weight store
+	f.indexedWeightStore = NewIndexedWeightStore(f)
+
 	return f, nil
 }
 

cl/phase1/forkchoice/get_head.go

@@ -23,6 +23,7 @@ import (
 	"sort"
 	"time"
 
+	"github.com/erigontech/erigon/cl/clparams"
 	"github.com/erigontech/erigon/cl/cltypes"
 	"github.com/erigontech/erigon/cl/cltypes/solid"
 	"github.com/erigontech/erigon/cl/phase1/core/state"
@@ -105,14 +106,94 @@ func (f *ForkChoiceStore) computeVotes(justifiedCheckpoint solid.Checkpoint, che
 }
 
 // GetHead returns the head of the fork choice store.
-// it can take an optional auxilliary state to determine the current weights instead of computing the justified state.
+// Dispatches to GLOAS or pre-GLOAS implementation based on current epoch.
 func (f *ForkChoiceStore) GetHead(auxilliaryState *state.CachingBeaconState) (common.Hash, uint64, error) {
 	f.mu.RLock()
 	if f.headHash != (common.Hash{}) {
 		f.mu.RUnlock()
 		return f.headHash, f.headSlot, nil
 	}
 	f.mu.RUnlock()
+
+	currentEpoch := f.computeEpochAtSlot(f.Slot())
+	if f.beaconCfg.GetCurrentStateVersion(currentEpoch) >= clparams.GloasVersion {
+		return f.getHeadGloas()
+	}
+	return f.getHeadPreGloas(auxilliaryState)
+}
+
+// getHeadGloas returns the head using GLOAS fork choice rules.
+// [New in Gloas:EIP7732]
+func (f *ForkChoiceStore) getHeadGloas() (common.Hash, uint64, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	justifiedCheckpoint := f.justifiedCheckpoint.Load().(solid.Checkpoint)
+
+	// Get filtered block tree
+	blocks := f.getFilteredBlockTree(justifiedCheckpoint.Root)
+
+	// Start from justified checkpoint with PENDING status
+	head := ForkChoiceNode{
+		Root:          justifiedCheckpoint.Root,
+		PayloadStatus: cltypes.PayloadStatusPending,
+	}
+
+	// Get weight store for weight calculation
+	ws := f.GetWeightStore()
+
+	for {
+		children := f.getNodeChildren(head, blocks)
+		if len(children) == 0 {
+			// No children, head is the result
+			header, hasHeader := f.forkGraph.GetHeader(head.Root)
+			if !hasHeader {
+				return common.Hash{}, 0, errors.New("no slot for head is stored")
+			}
+			f.headHash = head.Root
+			f.headSlot = header.Slot
+			return f.headHash, f.headSlot, nil
+		}
+
+		// Find best child: max(children, key=(weight, root, tiebreaker))
+		bestChild := children[0]
+		bestWeight := ws.GetWeight(bestChild)
+		bestTiebreaker := f.getPayloadStatusTiebreaker(bestChild)
+
+		for i := 1; i < len(children); i++ {
+			child := children[i]
+			weight := ws.GetWeight(child)
+			tiebreaker := f.getPayloadStatusTiebreaker(child)
+
+			// Compare: weight first, then root, then tiebreaker
+			if weight > bestWeight {
+				bestChild = child
+				bestWeight = weight
+				bestTiebreaker = tiebreaker
+			} else if weight == bestWeight {
+				// Compare by root (lexicographically greater wins)
+				rootCmp := bytes.Compare(child.Root[:], bestChild.Root[:])
+				if rootCmp > 0 {
+					bestChild = child
+					bestWeight = weight
+					bestTiebreaker = tiebreaker
+				} else if rootCmp == 0 {
+					// Same root, compare by tiebreaker
+					if tiebreaker > bestTiebreaker {
+						bestChild = child
+						bestWeight = weight
+						bestTiebreaker = tiebreaker
+					}
+				}
+			}
+		}
+
+		head = bestChild
+	}
+}
+
+// getHeadPreGloas returns the head using pre-GLOAS fork choice rules.
+func (f *ForkChoiceStore) getHeadPreGloas(auxilliaryState *state.CachingBeaconState) (common.Hash, uint64, error) {
 	justifiedCheckpoint := f.justifiedCheckpoint.Load().(solid.Checkpoint)
 	var justificationState *checkpointState
 	var err error

cl/phase1/forkchoice/interface.go

@@ -34,7 +34,8 @@ type ForkChoiceStorage interface {
 }
 
 type ForkChoiceStorageReader interface {
-	Ancestor(root common.Hash, slot uint64) common.Hash
+	// [Modified in Gloas:EIP7732] Returns ForkChoiceNode with payload status.
+	Ancestor(root common.Hash, slot uint64) ForkChoiceNode
 	AnchorSlot() uint64
 	Engine() execution_client.ExecutionEngine
 	FinalizedCheckpoint() solid.Checkpoint
@@ -96,6 +97,8 @@ type ForkChoiceStorageWriter interface {
 		fullValidation bool,
 		checkDataAvaibility bool,
 	) error
+	// [New in Gloas:EIP7732] OnExecutionPayload processes an execution payload envelope from the builder.
+	OnExecutionPayload(ctx context.Context, signedEnvelope *cltypes.SignedExecutionPayloadEnvelope) error
 	AddPreverifiedBlobSidecar(blobSidecar *cltypes.BlobSidecar) error
 	OnTick(time uint64)
 	SetSynced(synced bool)