Add InsertPayload to gloas forkchoice

beacon-chain/blockchain/chain_info.go

@@ -46,6 +46,7 @@ type ForkchoiceFetcher interface {
 	HighestReceivedBlockSlot() primitives.Slot
 	ReceivedBlocksLastEpoch() (uint64, error)
 	InsertNode(context.Context, state.BeaconState, consensus_blocks.ROBlock) error
+	InsertPayload(context.Context, interfaces.ROExecutionPayloadEnvelope) error
 	ForkChoiceDump(context.Context) (*forkchoice.Dump, error)
 	NewSlot(context.Context, primitives.Slot) error
 	ProposerBoost() [32]byte

beacon-chain/blockchain/chain_info_forkchoice.go

@@ -7,6 +7,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	consensus_blocks "github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/forkchoice"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
@@ -55,6 +56,13 @@ func (s *Service) InsertNode(ctx context.Context, st state.BeaconState, block co
 	return s.cfg.ForkChoiceStore.InsertNode(ctx, st, block)
 }
 
+// InsertPayload is a wrapper for payload insertion which is self locked
+func (s *Service) InsertPayload(ctx context.Context, pe interfaces.ROExecutionPayloadEnvelope) error {
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
+	return s.cfg.ForkChoiceStore.InsertPayload(ctx, pe)
+}
+
 // ForkChoiceDump returns the corresponding value from forkchoice
 func (s *Service) ForkChoiceDump(ctx context.Context) (*forkchoice.Dump, error) {
 	s.cfg.ForkChoiceStore.RLock()

beacon-chain/blockchain/testing/mock.go

@@ -700,6 +700,14 @@ func (s *ChainService) InsertNode(ctx context.Context, st state.BeaconState, blo
 	return nil
 }
 
+// InsertPayload mocks the same method in the chain service
+func (s *ChainService) InsertPayload(ctx context.Context, pe interfaces.ROExecutionPayloadEnvelope) error {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.InsertPayload(ctx, pe)
+	}
+	return nil
+}
+
 // ForkChoiceDump mocks the same method in the chain service
 func (s *ChainService) ForkChoiceDump(ctx context.Context) (*forkchoice2.Dump, error) {
 	if s.ForkChoiceStore != nil {

beacon-chain/forkchoice/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
         "//config/fieldparams:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/forkchoice:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],

beacon-chain/forkchoice/doubly-linked-tree/BUILD.bazel

@@ -52,6 +52,7 @@ go_test(
     srcs = [
         "ffg_update_test.go",
         "forkchoice_test.go",
+        "gloas_test.go",
         "no_vote_test.go",
         "node_test.go",
         "on_tick_test.go",
@@ -71,6 +72,7 @@ go_test(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/forkchoice:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/forkchoice/doubly-linked-tree/gloas.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"slices"
+	"time"
 
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
@@ -302,3 +303,25 @@ func (s *Store) nodeTreeDump(ctx context.Context, n *Node, nodes []*forkchoice2.
 	}
 	return nodes, nil
 }
+
+func (f *ForkChoice) InsertPayload(ctx context.Context, pe interfaces.ROExecutionPayloadEnvelope) error {
+	s := f.store
+	root := pe.BeaconBlockRoot()
+	en := s.emptyNodeByRoot[root]
+	if en == nil {
+		return errors.Wrap(ErrNilNode, "cannot insert full node without an empty one")
+	}
+	if _, ok := s.fullNodeByRoot[root]; ok {
+		// We don't import two payloads for the same root
+		return nil
+	}
+	fn := &PayloadNode{
+		node:       en.node,
+		optimistic: true,
+		timestamp:  time.Now(),
+		full:       true,
+		children:   make([]*Node, 0),
+	}
+	s.fullNodeByRoot[root] = fn
+	return nil
+}

beacon-chain/forkchoice/doubly-linked-tree/gloas_test.go

@@ -0,0 +1,300 @@
+package doublylinkedtree
+
+import (
+	"context"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/assert"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+)
+
+func prepareGloasForkchoiceState(
+	_ context.Context,
+	slot primitives.Slot,
+	blockRoot [32]byte,
+	parentRoot [32]byte,
+	blockHash [32]byte,
+	parentBlockHash [32]byte,
+	justifiedEpoch primitives.Epoch,
+	finalizedEpoch primitives.Epoch,
+) (state.BeaconState, blocks.ROBlock, error) {
+	blockHeader := &ethpb.BeaconBlockHeader{
+		ParentRoot: parentRoot[:],
+	}
+
+	justifiedCheckpoint := &ethpb.Checkpoint{
+		Epoch: justifiedEpoch,
+	}
+
+	finalizedCheckpoint := &ethpb.Checkpoint{
+		Epoch: finalizedEpoch,
+	}
+
+	builderPendingPayments := make([]*ethpb.BuilderPendingPayment, 64)
+	for i := range builderPendingPayments {
+		builderPendingPayments[i] = &ethpb.BuilderPendingPayment{
+			Withdrawal: &ethpb.BuilderPendingWithdrawal{
+				FeeRecipient: make([]byte, 20),
+			},
+		}
+	}
+
+	base := &ethpb.BeaconStateGloas{
+		Slot:                       slot,
+		RandaoMixes:                make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+		CurrentJustifiedCheckpoint: justifiedCheckpoint,
+		FinalizedCheckpoint:        finalizedCheckpoint,
+		LatestBlockHeader:          blockHeader,
+		LatestExecutionPayloadBid: &ethpb.ExecutionPayloadBid{
+			BlockHash:          blockHash[:],
+			ParentBlockHash:    parentBlockHash[:],
+			ParentBlockRoot:    make([]byte, 32),
+			PrevRandao:         make([]byte, 32),
+			FeeRecipient:       make([]byte, 20),
+			BlobKzgCommitments: [][]byte{make([]byte, 48)},
+		},
+		Builders:                     make([]*ethpb.Builder, 0),
+		BuilderPendingPayments:       builderPendingPayments,
+		ExecutionPayloadAvailability: make([]byte, 1024),
+		LatestBlockHash:              make([]byte, 32),
+		PayloadExpectedWithdrawals:   make([]*enginev1.Withdrawal, 0),
+		ProposerLookahead:            make([]uint64, 64),
+	}
+
+	st, err := state_native.InitializeFromProtoUnsafeGloas(base)
+	if err != nil {
+		return nil, blocks.ROBlock{}, err
+	}
+
+	bid := util.HydrateSignedExecutionPayloadBid(&ethpb.SignedExecutionPayloadBid{
+		Message: &ethpb.ExecutionPayloadBid{
+			BlockHash:       blockHash[:],
+			ParentBlockHash: parentBlockHash[:],
+		},
+	})
+
+	blk := util.HydrateSignedBeaconBlockGloas(&ethpb.SignedBeaconBlockGloas{
+		Block: &ethpb.BeaconBlockGloas{
+			Slot:       slot,
+			ParentRoot: parentRoot[:],
+			Body: &ethpb.BeaconBlockBodyGloas{
+				SignedExecutionPayloadBid: bid,
+			},
+		},
+	})
+
+	signed, err := blocks.NewSignedBeaconBlock(blk)
+	if err != nil {
+		return nil, blocks.ROBlock{}, err
+	}
+	roblock, err := blocks.NewROBlockWithRoot(signed, blockRoot)
+	return st, roblock, err
+}
+
+func prepareGloasForkchoicePayload(
+	blockRoot [32]byte,
+) (interfaces.ROExecutionPayloadEnvelope, error) {
+	env := &ethpb.ExecutionPayloadEnvelope{
+		BeaconBlockRoot: blockRoot[:],
+		Payload:         &enginev1.ExecutionPayloadDeneb{},
+	}
+	return blocks.WrappedROExecutionPayloadEnvelope(env)
+}
+
+func TestInsertGloasBlock_EmptyNodeOnly(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	root := indexToHash(1)
+	blockHash := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, root, params.BeaconConfig().ZeroHash, blockHash, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	// Empty node should exist.
+	en := f.store.emptyNodeByRoot[root]
+	require.NotNil(t, en)
+
+	// Full node should NOT exist.
+	_, hasFull := f.store.fullNodeByRoot[root]
+	assert.Equal(t, false, hasFull)
+
+	// Parent should be the genesis full node.
+	genesisRoot := params.BeaconConfig().ZeroHash
+	genesisFull := f.store.fullNodeByRoot[genesisRoot]
+	require.NotNil(t, genesisFull)
+	assert.Equal(t, genesisFull, en.node.parent)
+}
+
+func TestInsertPayload_CreatesFullNode(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	root := indexToHash(1)
+	blockHash := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, root, params.BeaconConfig().ZeroHash, blockHash, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+	require.Equal(t, 2, len(f.store.emptyNodeByRoot))
+	require.Equal(t, 1, len(f.store.fullNodeByRoot))
+
+	pe, err := prepareGloasForkchoicePayload(root)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertPayload(ctx, pe))
+	require.Equal(t, 2, len(f.store.fullNodeByRoot))
+
+	fn := f.store.fullNodeByRoot[root]
+	require.NotNil(t, fn)
+
+	en := f.store.emptyNodeByRoot[root]
+	require.NotNil(t, en)
+
+	// Empty and full share the same *Node.
+	assert.Equal(t, en.node, fn.node)
+	assert.Equal(t, true, fn.optimistic)
+	assert.Equal(t, true, fn.full)
+}
+
+func TestInsertPayload_DuplicateIsNoop(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	root := indexToHash(1)
+	blockHash := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, root, params.BeaconConfig().ZeroHash, blockHash, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	pe, err := prepareGloasForkchoicePayload(root)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertPayload(ctx, pe))
+	require.Equal(t, 2, len(f.store.fullNodeByRoot))
+
+	fn := f.store.fullNodeByRoot[root]
+	require.NotNil(t, fn)
+
+	// Insert again — should be a no-op.
+	require.NoError(t, f.InsertPayload(ctx, pe))
+	assert.Equal(t, fn, f.store.fullNodeByRoot[root])
+	require.Equal(t, 2, len(f.store.fullNodeByRoot))
+}
+
+func TestInsertPayload_WithoutEmptyNode_Errors(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	root := indexToHash(99)
+	pe, err := prepareGloasForkchoicePayload(root)
+	require.NoError(t, err)
+
+	err = f.InsertPayload(ctx, pe)
+	require.ErrorContains(t, ErrNilNode.Error(), err)
+}
+
+func TestGloasBlock_ChildBuildsOnEmpty(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	// Insert Gloas block A (empty only).
+	rootA := indexToHash(1)
+	blockHashA := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, rootA, params.BeaconConfig().ZeroHash, blockHashA, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	// Insert Gloas block B as child of (A, empty)
+	rootB := indexToHash(2)
+	blockHashB := indexToHash(200)
+	nonMatchingParentHash := indexToHash(999)
+	st, roblock, err = prepareGloasForkchoiceState(ctx, 2, rootB, rootA, blockHashB, nonMatchingParentHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	emptyA := f.store.emptyNodeByRoot[rootA]
+	require.NotNil(t, emptyA)
+	nodeB := f.store.emptyNodeByRoot[rootB]
+	require.NotNil(t, nodeB)
+	require.Equal(t, emptyA, nodeB.node.parent)
+}
+
+func TestGloasBlock_ChildrenOfEmptyAndFull(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	// Insert Gloas block A (empty only).
+	rootA := indexToHash(1)
+	blockHashA := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, rootA, params.BeaconConfig().ZeroHash, blockHashA, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+	// Insert payload for A
+	pe, err := prepareGloasForkchoicePayload(rootA)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertPayload(ctx, pe))
+
+	// Insert Gloas block B as child of (A, empty)
+	rootB := indexToHash(2)
+	blockHashB := indexToHash(200)
+	nonMatchingParentHash := indexToHash(999)
+	st, roblock, err = prepareGloasForkchoiceState(ctx, 2, rootB, rootA, blockHashB, nonMatchingParentHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	// Insert Gloas block C as child of (A, full)
+	rootC := indexToHash(3)
+	blockHashC := indexToHash(201)
+	st, roblock, err = prepareGloasForkchoiceState(ctx, 3, rootC, rootA, blockHashC, blockHashA, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	emptyA := f.store.emptyNodeByRoot[rootA]
+	require.NotNil(t, emptyA)
+	nodeB := f.store.emptyNodeByRoot[rootB]
+	require.NotNil(t, nodeB)
+	require.Equal(t, emptyA, nodeB.node.parent)
+	nodeC := f.store.emptyNodeByRoot[rootC]
+	require.NotNil(t, nodeC)
+	fullA := f.store.fullNodeByRoot[rootA]
+	require.NotNil(t, fullA)
+	require.Equal(t, fullA, nodeC.node.parent)
+}
+
+func TestGloasBlock_ChildBuildsOnFull(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	// Insert Gloas block A (empty only).
+	rootA := indexToHash(1)
+	blockHashA := indexToHash(100)
+	st, roblock, err := prepareGloasForkchoiceState(ctx, 1, rootA, params.BeaconConfig().ZeroHash, blockHashA, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	// Insert payload for A → creates the full node.
+	pe, err := prepareGloasForkchoicePayload(rootA)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertPayload(ctx, pe))
+
+	fullA := f.store.fullNodeByRoot[rootA]
+	require.NotNil(t, fullA)
+
+	// Child for (A, full)
+	rootB := indexToHash(2)
+	blockHashB := indexToHash(200)
+	st, roblock, err = prepareGloasForkchoiceState(ctx, 2, rootB, rootA, blockHashB, blockHashA, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, roblock))
+
+	nodeB := f.store.emptyNodeByRoot[rootB]
+	require.NotNil(t, nodeB)
+	assert.Equal(t, fullA, nodeB.node.parent)
+}

beacon-chain/forkchoice/doubly-linked-tree/store.go

@@ -136,6 +136,7 @@ func (s *Store) insert(ctx context.Context,
 		node:       n,
 		optimistic: optimistic,
 		timestamp:  time.Now(),
+		children:   make([]*Node, 0),
 	}
 	s.emptyNodeByRoot[root] = pn
 	ret = pn

beacon-chain/forkchoice/interfaces.go

@@ -9,6 +9,7 @@ import (
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	consensus_blocks "github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	forkchoice2 "github.com/OffchainLabs/prysm/v7/consensus-types/forkchoice"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 )
 
@@ -23,6 +24,7 @@ type ForkChoicer interface {
 	Unlock()
 	HeadRetriever        // to compute head.
 	BlockProcessor       // to track new block for fork choice.
+	PayloadProcessor     // to track new payloads for fork choice.
 	AttestationProcessor // to track new attestation for fork choice.
 	Getter               // to retrieve fork choice information.
 	Setter               // to set fork choice information.
@@ -47,6 +49,11 @@ type BlockProcessor interface {
 	InsertChain(context.Context, []*forkchoicetypes.BlockAndCheckpoints) error
 }
 
+// PayloadProcessor processes a payload envelope
+type PayloadProcessor interface {
+	InsertPayload(context.Context, interfaces.ROExecutionPayloadEnvelope) error
+}
+
 // AttestationProcessor processes the attestation that's used for accounting fork choice.
 type AttestationProcessor interface {
 	ProcessAttestation(context.Context, []uint64, [32]byte, primitives.Epoch)

changelog/potuz_gloas_forkchoice_insert_payload.md

@@ -0,0 +1,2 @@
+### Added
+- Added an InsertPayload method to allow full node insertion after gloas.