Implement EIP7805: Fork-choice enforced Inclusion Lists

CHANGELOG.md

@@ -21,6 +21,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - DB optimization for saving light client bootstraps (save unique sync committees only).
 - Trace IDONTWANT Messages in Pubsub.
 - Add Fulu fork boilerplate.
+- FOCIL.
 
 ### Changed
 

beacon-chain/blockchain/BUILD.bazel

@@ -12,6 +12,7 @@ go_library(
         "forkchoice_update_execution.go",
         "head.go",
         "head_sync_committee_info.go",
+        "inclusion_list.go",
         "init_sync_process_block.go",
         "log.go",
         "merge_ascii_art.go",

beacon-chain/blockchain/chain_info.go

@@ -69,6 +69,7 @@ type GenesisFetcher interface {
 type HeadFetcher interface {
 	HeadSlot() primitives.Slot
 	HeadRoot(ctx context.Context) ([]byte, error)
+	FilteredHeadRoot(ctx context.Context) ([32]byte, error)
 	HeadBlock(ctx context.Context) (interfaces.ReadOnlySignedBeaconBlock, error)
 	HeadState(ctx context.Context) (state.BeaconState, error)
 	HeadStateReadOnly(ctx context.Context) (state.ReadOnlyBeaconState, error)
@@ -180,6 +181,39 @@ func (s *Service) HeadRoot(ctx context.Context) ([]byte, error) {
 	return r[:], nil
 }
 
+// FilteredHeadRoot returns the filtered head root of the chain.
+// If the head root does not satisfy the inclusion list constraint,
+// its parent root is returned.
+func (s *Service) FilteredHeadRoot(ctx context.Context) ([32]byte, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
+	if s.head != nil && s.head.root != params.BeaconConfig().ZeroHash {
+		if s.head.root == s.badInclusionListBlock {
+			return s.head.block.Block().ParentRoot(), nil
+		}
+		return s.head.root, nil
+	}
+
+	headBlock, err := s.cfg.BeaconDB.HeadBlock(ctx)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	if headBlock == nil || headBlock.IsNil() {
+		return params.BeaconConfig().ZeroHash, nil
+	}
+
+	root, err := headBlock.Block().HashTreeRoot()
+	if err != nil {
+		return [32]byte{}, err
+	}
+	if root == s.badInclusionListBlock {
+		return headBlock.Block().ParentRoot(), nil
+	}
+
+	return root, nil
+}
+
 // HeadBlock returns the head block of the chain.
 // If the head is nil from service struct,
 // it will attempt to get the head block from DB.

beacon-chain/blockchain/execution_engine.go

@@ -269,12 +269,29 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int,
 			return false, errors.Wrap(err, "could not get execution requests")
 		}
 	}
-	lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, parentRoot, requests)
+
+	txs := make([][]byte, 0)
+	// Post-FOCIL, only consider the inclusion list constraint if it matches the current slot.
+	if slots.ToEpoch(s.CurrentSlot()) >= params.BeaconConfig().FocilForkEpoch && s.CurrentSlot() == blk.Block().Slot() {
+		txs = s.inclusionListCache.Get(blk.Block().Slot())
+	}
+	lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, parentRoot, requests, txs)
 
 	switch {
 	case err == nil:
 		newPayloadValidNodeCount.Inc()
 		return true, nil
+	case errors.Is(err, execution.ErrBadInclusionListPayloadStatus):
+		log.WithFields(logrus.Fields{
+			"slot":       blk.Block().Slot(),
+			"parentRoot": fmt.Sprintf("%#x", parentRoot),
+		}).Info("Called new payload but inclusion list didn't satisfy")
+		r, err := blk.Block().HashTreeRoot()
+		if err != nil {
+			return false, errors.Wrap(err, "could not get block hash tree root")
+		}
+		s.badInclusionListBlock = r // Cache the block root that fails to satisfy the inclusion list constraint.
+		return true, nil
 	case errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus):
 		newPayloadOptimisticNodeCount.Inc()
 		log.WithFields(logrus.Fields{

beacon-chain/blockchain/inclusion_list.go

@@ -0,0 +1,59 @@
+package blockchain
+
+import (
+	"context"
+	"time"
+
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+const updateInclusionListBlockInterval = time.Second
+
+// Routine that updates block building with inclusion lists one second before the slot starts.
+func (s *Service) updateBlockWithInclusionListRoutine() {
+	if err := s.waitForSync(); err != nil {
+		log.WithError(err).Error("Failed to wait for initial sync")
+		return
+	}
+
+	interval := time.Second*time.Duration(params.BeaconConfig().SecondsPerSlot) - updateInclusionListBlockInterval
+	ticker := slots.NewSlotTickerWithIntervals(s.genesisTime, []time.Duration{interval})
+
+	for {
+		select {
+		case <-s.ctx.Done():
+			return
+		case <-ticker.C():
+			s.updateBlockWithInclusionList(context.Background())
+		}
+	}
+}
+
+// Updates block building with inclusion lists, the current payload ID, and the new upload ID.
+func (s *Service) updateBlockWithInclusionList(ctx context.Context) {
+	currentSlot := s.CurrentSlot()
+
+	// Skip update if not in or past the FOCIL fork epoch.
+	if slots.ToEpoch(currentSlot) < params.BeaconConfig().FocilForkEpoch {
+		return
+	}
+
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+
+	headRoot := s.headRoot()
+	id, found := s.cfg.PayloadIDCache.PayloadID(currentSlot+1, headRoot)
+	if !found {
+		return
+	}
+
+	txs := s.inclusionListCache.Get(currentSlot)
+	newID, err := s.cfg.ExecutionEngineCaller.UpdatePayloadWithInclusionList(ctx, id, txs)
+	if err != nil {
+		log.WithError(err).Error("Failed to update block with inclusion list")
+		return
+	}
+
+	s.cfg.PayloadIDCache.Set(currentSlot+1, headRoot, *newID)
+}

beacon-chain/blockchain/service.go

@@ -47,24 +47,26 @@ import (
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	cfg                  *config
-	ctx                  context.Context
-	cancel               context.CancelFunc
-	genesisTime          time.Time
-	head                 *head
-	headLock             sync.RWMutex
-	originBlockRoot      [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
-	boundaryRoots        [][32]byte
-	checkpointStateCache *cache.CheckpointStateCache
-	initSyncBlocks       map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
-	initSyncBlocksLock   sync.RWMutex
-	wsVerifier           *WeakSubjectivityVerifier
-	clockSetter          startup.ClockSetter
-	clockWaiter          startup.ClockWaiter
-	syncComplete         chan struct{}
-	blobNotifiers        *blobNotifierMap
-	blockBeingSynced     *currentlySyncingBlock
-	blobStorage          *filesystem.BlobStorage
+	cfg                   *config
+	ctx                   context.Context
+	cancel                context.CancelFunc
+	genesisTime           time.Time
+	head                  *head
+	headLock              sync.RWMutex
+	originBlockRoot       [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
+	boundaryRoots         [][32]byte
+	checkpointStateCache  *cache.CheckpointStateCache
+	initSyncBlocks        map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
+	initSyncBlocksLock    sync.RWMutex
+	wsVerifier            *WeakSubjectivityVerifier
+	clockSetter           startup.ClockSetter
+	clockWaiter           startup.ClockWaiter
+	syncComplete          chan struct{}
+	blobNotifiers         *blobNotifierMap
+	blockBeingSynced      *currentlySyncingBlock
+	blobStorage           *filesystem.BlobStorage
+	inclusionListCache    *cache.InclusionLists
+	badInclusionListBlock [32]byte
 }
 
 // config options for the service.
@@ -215,6 +217,7 @@ func (s *Service) Start() {
 	}
 	s.spawnProcessAttestationsRoutine()
 	go s.runLateBlockTasks()
+	go s.updateBlockWithInclusionListRoutine()
 }
 
 // Stop the blockchain service's main event loop and associated goroutines.

beacon-chain/blockchain/testing/mock.go

@@ -348,6 +348,13 @@ func (s *ChainService) HeadRoot(_ context.Context) ([]byte, error) {
 	return make([]byte, 32), nil
 }
 
+func (s *ChainService) FilteredHeadRoot(_ context.Context) ([32]byte, error) {
+	if len(s.Root) > 0 {
+		return bytesutil.ToBytes32(s.Root), nil
+	}
+	return [32]byte{}, nil
+}
+
 // HeadBlock mocks HeadBlock method in chain service.
 func (s *ChainService) HeadBlock(context.Context) (interfaces.ReadOnlySignedBeaconBlock, error) {
 	return s.Block, nil

beacon-chain/cache/BUILD.bazel

@@ -15,6 +15,7 @@ go_library(
         "common.go",
         "doc.go",
         "error.go",
+        "inclusion_list.go",
         "interfaces.go",
         "payload_id.go",
         "proposer_indices.go",
@@ -75,6 +76,7 @@ go_test(
         "checkpoint_state_test.go",
         "committee_fuzz_test.go",
         "committee_test.go",
+        "inclusion_list_test.go",
         "payload_id_test.go",
         "private_access_test.go",
         "proposer_indices_test.go",

beacon-chain/cache/inclusion_list.go

@@ -0,0 +1,98 @@
+package cache
+
+import (
+	"crypto/sha256"
+	"sync"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+)
+
+type InclusionLists struct {
+	mu  sync.RWMutex
+	ils map[primitives.Slot]map[primitives.ValidatorIndex]struct {
+		txs       [][]byte
+		seenTwice bool
+	}
+}
+
+// NewInclusionLists initializes a new InclusionLists instance.
+func NewInclusionLists() *InclusionLists {
+	return &InclusionLists{
+		ils: make(map[primitives.Slot]map[primitives.ValidatorIndex]struct {
+			txs       [][]byte
+			seenTwice bool
+		}),
+	}
+}
+
+// Add adds a set of transactions for a specific slot and validator index.
+func (i *InclusionLists) Add(slot primitives.Slot, validatorIndex primitives.ValidatorIndex, txs [][]byte) {
+	i.mu.Lock()
+	defer i.mu.Unlock()
+
+	if _, ok := i.ils[slot]; !ok {
+		i.ils[slot] = make(map[primitives.ValidatorIndex]struct {
+			txs       [][]byte
+			seenTwice bool
+		})
+	}
+
+	entry := i.ils[slot][validatorIndex]
+	if entry.seenTwice {
+		return // No need to modify if already marked as seen twice.
+	}
+
+	if entry.txs == nil {
+		entry.txs = txs
+	} else {
+		entry.seenTwice = true
+		entry.txs = nil // Clear transactions to save space if seen twice.
+	}
+	i.ils[slot][validatorIndex] = entry
+}
+
+// Get retrieves unique transactions for a specific slot.
+func (i *InclusionLists) Get(slot primitives.Slot) [][]byte {
+	i.mu.RLock()
+	defer i.mu.RUnlock()
+
+	ils, exists := i.ils[slot]
+	if !exists {
+		return nil
+	}
+
+	var uniqueTxs [][]byte
+	seen := make(map[[32]byte]struct{})
+	for _, entry := range ils {
+		for _, tx := range entry.txs {
+			hash := sha256.Sum256(tx)
+			if _, duplicate := seen[hash]; !duplicate {
+				uniqueTxs = append(uniqueTxs, tx)
+				seen[hash] = struct{}{}
+			}
+		}
+	}
+	return uniqueTxs
+}
+
+// Delete removes all inclusion lists for a specific slot.
+func (i *InclusionLists) Delete(slot primitives.Slot) {
+	i.mu.Lock()
+	defer i.mu.Unlock()
+
+	delete(i.ils, slot)
+}
+
+// SeenTwice checks if a validator's transactions were marked as seen twice for a specific slot.
+func (i *InclusionLists) SeenTwice(slot primitives.Slot, idx primitives.ValidatorIndex) bool {
+	i.mu.RLock()
+	defer i.mu.RUnlock()
+
+	ils, exists := i.ils[slot]
+	if !exists {
+		return false
+	}
+
+	entry, exists := ils[idx]
+	return exists && entry.seenTwice
+}