merge with prysm upstream

api/gateway/apimiddleware/process_field.go

@@ -26,6 +26,23 @@ func processField(s interface{}, processors []fieldProcessor) error {
 	t := reflect.TypeOf(s).Elem()
 	v := reflect.Indirect(reflect.ValueOf(s))
 
+	if t.Kind() == reflect.Struct {
+		err := processStructField(t, v, processors)
+		return err
+	} else if t.Kind() == reflect.Slice {
+		for i := 0; i < v.Len(); i++ {
+			if err := processField(v.Index(i).Interface(), processors); err != nil {
+				return errors.Wrapf(err, "could not process field '%s'", t.Name())
+			}
+		}
+	} else {
+		return fmt.Errorf("processing fields of kind '%v' is unsupported", t.Kind())
+	}
+
+	return nil
+}
+
+func processStructField(t reflect.Type, v reflect.Value, processors []fieldProcessor) error {
 	for i := 0; i < t.NumField(); i++ {
 		switch v.Field(i).Kind() {
 		case reflect.Slice:

beacon-chain/blockchain/BUILD.bazel

@@ -61,6 +61,7 @@ go_library(
         "//beacon-chain/startup:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
+        "//beacon-chain/rpc/eth/helpers/lightclient:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -75,6 +76,8 @@ go_library(
         "//monitoring/tracing:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
+        "//proto/eth/v2:go_default_library",
+        "//proto/migration:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
@@ -140,6 +143,7 @@ go_test(
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
+        "//beacon-chain/rpc/eth/helpers/lightclient:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -196,6 +200,7 @@ go_test(
         "//beacon-chain/execution/testing:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/p2p:go_default_library",
+        "//beacon-chain/rpc/eth/helpers/lightclient:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/blocks/testing:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
@@ -333,6 +334,11 @@ func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index primiti
 	return v.PublicKey(), nil
 }
 
+// ForkChoicer returns the forkchoice interface.
+func (s *Service) ForkChoicer() forkchoice.ForkChoicer {
+	return s.cfg.ForkChoiceStore
+}
+
 // IsOptimistic returns true if the current head is optimistic.
 func (s *Service) IsOptimistic(_ context.Context) (bool, error) {
 	if slots.ToEpoch(s.CurrentSlot()) < params.BeaconConfig().BellatrixForkEpoch {

beacon-chain/blockchain/process_block.go

@@ -13,6 +13,7 @@ import (
 	coreTime "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/transition"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/types"
+	lightclienthelpers "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/helpers/lightclient"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v4/config/features"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
@@ -22,6 +23,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/monitoring/tracing"
+	ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
@@ -39,6 +41,97 @@ const depositDeadline = 20 * time.Second
 // This defines size of the upper bound for initial sync block cache.
 var initialSyncBlockCacheSize = uint64(2 * params.BeaconConfig().SlotsPerEpoch)
 
+// sendLightClientFinalityUpdate sends a light client finality update notification of  to the state feed.
+func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
+	postState state.BeaconState) (int, error) {
+	// Determine slots per period
+	config := params.BeaconConfig()
+
+	// Get attested state
+	attestedRoot := signed.Block().ParentRoot()
+	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
+	if err != nil {
+		return 0, errors.Wrap(err, "could not get attested state")
+	}
+
+	// Get finalized block
+	var finalizedBlock interfaces.ReadOnlySignedBeaconBlock
+	finalizedCheckPoint := attestedState.FinalizedCheckpoint()
+	if finalizedCheckPoint != nil {
+		finalizedRoot := bytesutil.ToBytes32(finalizedCheckPoint.Root)
+		finalizedBlock, err = s.cfg.BeaconDB.Block(ctx, finalizedRoot)
+		if err != nil {
+			finalizedBlock = nil
+		}
+	}
+
+	update, err := lightclienthelpers.NewLightClientFinalityUpdateFromBeaconState(
+		ctx,
+		config,
+		postState,
+		signed,
+		attestedState,
+		finalizedBlock,
+	)
+
+	if err != nil {
+		return 0, errors.Wrap(err, "could not create light client update")
+	}
+
+	finalityUpdate := lightclienthelpers.NewLightClientFinalityUpdateFromUpdate(update)
+
+	// Return the result
+	result := &ethpbv2.LightClientFinalityUpdateResponse{
+		Version: ethpbv2.Version(signed.Version()),
+		Data:    finalityUpdate,
+	}
+
+	// Send event
+	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+		Type: statefeed.LightClientFinalityUpdate,
+		Data: result,
+	}), nil
+}
+
+// sendLightClientOptimisticUpdate sends a light client optimistic update notification of  to the state feed.
+func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
+	postState state.BeaconState) (int, error) {
+	// Determine slots per period
+	config := params.BeaconConfig()
+
+	// Get attested state
+	attestedRoot := signed.Block().ParentRoot()
+	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
+	if err != nil {
+		return 0, errors.Wrap(err, "could not get attested state")
+	}
+
+	update, err := lightclienthelpers.NewLightClientOptimisticUpdateFromBeaconState(
+		ctx,
+		config,
+		postState,
+		signed,
+		attestedState,
+	)
+
+	if err != nil {
+		return 0, errors.Wrap(err, "could not create light client update")
+	}
+
+	optimisticUpdate := lightclienthelpers.NewLightClientOptimisticUpdateFromUpdate(update)
+
+	// Return the result
+	result := &ethpbv2.LightClientOptimisticUpdateResponse{
+		Version: ethpbv2.Version(signed.Version()),
+		Data:    optimisticUpdate,
+	}
+
+	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+		Type: statefeed.LightClientOptimisticUpdate,
+		Data: result,
+	}), nil
+}
+
 // postBlockProcess is called when a gossip block is received. This function performs
 // several duties most importantly informing the engine if head was updated,
 // saving the new head information to the blockchain package and database and
@@ -118,6 +211,16 @@ func (s *Service) postBlockProcess(ctx context.Context, signed interfaces.ReadOn
 		},
 	})
 
+	if _, err := s.sendLightClientOptimisticUpdate(ctx, signed, postState); err != nil {
+		log.WithError(err)
+	}
+
+	// Save finalized check point to db and more.
+	finalized := s.ForkChoicer().FinalizedCheckpoint()
+
+	// LightClientFinalityUpdate needs super majority
+	s.tryPublishLightClientFinalityUpdate(ctx, signed, finalized, postState)
+
 	defer reportAttestationInclusion(b)
 	if err := s.handleEpochBoundary(ctx, postState, blockRoot[:]); err != nil {
 		return err
@@ -126,6 +229,33 @@ func (s *Service) postBlockProcess(ctx context.Context, signed interfaces.ReadOn
 	return nil
 }
 
+func (s *Service) tryPublishLightClientFinalityUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock, finalized *forkchoicetypes.Checkpoint, postState state.BeaconState) {
+	if finalized.Epoch <= s.lastPublishedLightClientEpoch {
+		return
+	}
+
+	config := params.BeaconConfig()
+	if finalized.Epoch < config.AltairForkEpoch {
+		return
+	}
+
+	syncAggregate, err := signed.Block().Body().SyncAggregate()
+	if err != nil || syncAggregate == nil {
+		return
+	}
+
+	if syncAggregate.SyncCommitteeBits.Count()*3 < config.SyncCommitteeSize*2 {
+		return
+	}
+
+	_, err = s.sendLightClientFinalityUpdate(ctx, signed, postState)
+	if err != nil {
+		log.WithError(err)
+	} else {
+		s.lastPublishedLightClientEpoch = finalized.Epoch
+	}
+}
+
 func getStateVersionAndPayload(st state.BeaconState) (int, interfaces.ExecutionData, error) {
 	if st == nil {
 		return 0, nil, errors.New("nil state")

beacon-chain/blockchain/process_block_helpers.go

@@ -212,42 +212,40 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfa
 
 // inserts finalized deposits into our finalized deposit trie, needs to be
 // called in the background
-func (s *Service) insertFinalizedDeposits(ctx context.Context, fRoot [32]byte) {
+func (s *Service) insertFinalizedDeposits(ctx context.Context, fRoot [32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.insertFinalizedDeposits")
 	defer span.End()
 	startTime := time.Now()
 
 	// Update deposit cache.
 	finalizedState, err := s.cfg.StateGen.StateByRoot(ctx, fRoot)
 	if err != nil {
-		log.WithError(err).Error("could not fetch finalized state")
-		return
+		return errors.Wrap(err, "could not fetch finalized state")
 	}
 	// We update the cache up to the last deposit index in the finalized block's state.
 	// We can be confident that these deposits will be included in some block
 	// because the Eth1 follow distance makes such long-range reorgs extremely unlikely.
 	eth1DepositIndex, err := mathutil.Int(finalizedState.Eth1DepositIndex())
 	if err != nil {
-		log.WithError(err).Error("could not cast eth1 deposit index")
-		return
+		return errors.Wrap(err, "could not cast eth1 deposit index")
 	}
 	// The deposit index in the state is always the index of the next deposit
 	// to be included(rather than the last one to be processed). This was most likely
 	// done as the state cannot represent signed integers.
 	finalizedEth1DepIdx := eth1DepositIndex - 1
 	if err = s.cfg.DepositCache.InsertFinalizedDeposits(ctx, int64(finalizedEth1DepIdx)); err != nil {
-		log.WithError(err).Error("could not insert finalized deposits")
-		return
+		return errors.Wrap(err, "could not insert finalized deposits")
 	}
 	// Deposit proofs are only used during state transition and can be safely removed to save space.
 	if err = s.cfg.DepositCache.PruneProofs(ctx, int64(finalizedEth1DepIdx)); err != nil {
-		log.WithError(err).Error("could not prune deposit proofs")
+		return errors.Wrap(err, "could not prune deposit proofs")
 	}
 	// Prune deposits which have already been finalized, the below method prunes all pending deposits (non-inclusive) up
 	// to the provided eth1 deposit index.
 	s.cfg.DepositCache.PrunePendingDeposits(ctx, int64(eth1DepositIndex)) // lint:ignore uintcast -- Deposit index should not exceed int64 in your lifetime.
 
 	log.WithField("duration", time.Since(startTime).String()).Debug("Finalized deposit insertion completed")
+	return nil
 }
 
 // This ensures that the input root defaults to using genesis root instead of zero hashes. This is needed for handling

beacon-chain/blockchain/receive_block.go

@@ -103,7 +103,9 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 		go s.sendNewFinalizedEvent(ctx, blockCopy, postState, finalized)
 		depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline)
 		go func() {
-			s.insertFinalizedDeposits(depCtx, finalized.Root)
+			if err := s.insertFinalizedDeposits(depCtx, finalized.Root); err != nil {
+				log.WithError(err).Error("Could not insert finalized deposits.")
+			}
 			cancel()
 		}()
 	}

beacon-chain/blockchain/service.go

@@ -46,22 +46,23 @@ 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
-	nextEpochBoundarySlot primitives.Slot
-	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{}
+	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
+	nextEpochBoundarySlot         primitives.Slot
+	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{}
+	lastPublishedLightClientEpoch primitives.Epoch
 }
 
 // config options for the service.

beacon-chain/core/feed/state/events.go

@@ -27,6 +27,10 @@ const (
 	NewHead
 	// MissedSlot is sent when we need to notify users that a slot was missed.
 	MissedSlot
+	// LightClientFinalityUpdate event
+	LightClientFinalityUpdate
+	// LightClientOptimisticUpdate event
+	LightClientOptimisticUpdate
 )
 
 // BlockProcessedData is the data sent with BlockProcessed events.

beacon-chain/lightclient/BUILD.bazel

@@ -0,0 +1,13 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "config.go",
+	"helpers.go",
+        "store.go",
+        "update.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/v3/beacon-chain/lightclient",
+    visibility = ["//visibility:public"],
+)