Revert archival deprecations (#5464)

* Revert "Fix `ListValidatorBalances` for v0.11 (#5458)"

This reverts commit 3763a8c.
* Revert "Deprecate archival service (#5445)"

This reverts commit 4fbcedf.
* Revert "Delete archival DB methods (#5459)"

This reverts commit 8a3ea1e.
* Revert "Modify `ListBeaconCommittees ` to use new state service  (#5411)"

This reverts commit 497fa6e.
* Revert "Modify `GetValidatorParticipation` to use new state service (#5409)"

This reverts commit 046a00a.
* Revert "Modify `GetValidatorActiveSetChanges` to use new state service  (#5408)"

This reverts commit 5eb6485.
* Revert "Modify `ListValidatorAssignments` to use new state service (#5365)"

This reverts commit 5a1a768.

beacon-chain/archiver/BUILD.bazel

@@ -0,0 +1,45 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["service.go"],
+    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/archiver",
+    visibility = ["//beacon-chain:__subpackages__"],
+    deps = [
+        "//beacon-chain/blockchain:go_default_library",
+        "//beacon-chain/core/feed:go_default_library",
+        "//beacon-chain/core/feed/state:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/validators:go_default_library",
+        "//beacon-chain/db:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//shared/params:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["service_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//beacon-chain/blockchain/testing:go_default_library",
+        "//beacon-chain/core/epoch/precompute:go_default_library",
+        "//beacon-chain/core/feed:go_default_library",
+        "//beacon-chain/core/feed/state:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/db:go_default_library",
+        "//beacon-chain/db/testing:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/testutil:go_default_library",
+        "@com_github_gogo_protobuf//proto:go_default_library",
+        "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+    ],
+)

beacon-chain/archiver/service.go

@@ -0,0 +1,200 @@
+package archiver
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
+	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
+	"github.com/prysmaticlabs/prysm/beacon-chain/db"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/sirupsen/logrus"
+)
+
+var log = logrus.WithField("prefix", "archiver")
+
+// Service defining archiver functionality for persisting checkpointed
+// beacon chain information to a database backend for historical purposes.
+type Service struct {
+	ctx                  context.Context
+	cancel               context.CancelFunc
+	beaconDB             db.NoHeadAccessDatabase
+	headFetcher          blockchain.HeadFetcher
+	participationFetcher blockchain.ParticipationFetcher
+	stateNotifier        statefeed.Notifier
+	lastArchivedEpoch    uint64
+}
+
+// Config options for the archiver service.
+type Config struct {
+	BeaconDB             db.NoHeadAccessDatabase
+	HeadFetcher          blockchain.HeadFetcher
+	ParticipationFetcher blockchain.ParticipationFetcher
+	StateNotifier        statefeed.Notifier
+}
+
+// NewArchiverService initializes the service from configuration options.
+func NewArchiverService(ctx context.Context, cfg *Config) *Service {
+	ctx, cancel := context.WithCancel(ctx)
+	return &Service{
+		ctx:                  ctx,
+		cancel:               cancel,
+		beaconDB:             cfg.BeaconDB,
+		headFetcher:          cfg.HeadFetcher,
+		participationFetcher: cfg.ParticipationFetcher,
+		stateNotifier:        cfg.StateNotifier,
+	}
+}
+
+// Start the archiver service event loop.
+func (s *Service) Start() {
+	go s.run(s.ctx)
+}
+
+// Stop the archiver service event loop.
+func (s *Service) Stop() error {
+	defer s.cancel()
+	return nil
+}
+
+// Status reports the healthy status of the archiver. Returning nil means service
+// is correctly running without error.
+func (s *Service) Status() error {
+	return nil
+}
+
+// We archive committee information pertaining to the head state's epoch.
+func (s *Service) archiveCommitteeInfo(ctx context.Context, headState *state.BeaconState, epoch uint64) error {
+	proposerSeed, err := helpers.Seed(headState, epoch, params.BeaconConfig().DomainBeaconProposer)
+	if err != nil {
+		return errors.Wrap(err, "could not generate seed")
+	}
+	attesterSeed, err := helpers.Seed(headState, epoch, params.BeaconConfig().DomainBeaconAttester)
+	if err != nil {
+		return errors.Wrap(err, "could not generate seed")
+	}
+
+	info := &pb.ArchivedCommitteeInfo{
+		ProposerSeed: proposerSeed[:],
+		AttesterSeed: attesterSeed[:],
+	}
+	if err := s.beaconDB.SaveArchivedCommitteeInfo(ctx, epoch, info); err != nil {
+		return errors.Wrap(err, "could not archive committee info")
+	}
+	return nil
+}
+
+// We archive active validator set changes that happened during the previous epoch.
+func (s *Service) archiveActiveSetChanges(ctx context.Context, headState *state.BeaconState, epoch uint64) error {
+	prevEpoch := epoch - 1
+	vals := headState.Validators()
+	activations := validators.ActivatedValidatorIndices(prevEpoch, vals)
+	slashings := validators.SlashedValidatorIndices(prevEpoch, vals)
+	activeValidatorCount, err := helpers.ActiveValidatorCount(headState, prevEpoch)
+	if err != nil {
+		return errors.Wrap(err, "could not get active validator count")
+	}
+	exited, err := validators.ExitedValidatorIndices(prevEpoch, vals, activeValidatorCount)
+	if err != nil {
+		return errors.Wrap(err, "could not determine exited validator indices")
+	}
+	activeSetChanges := &pb.ArchivedActiveSetChanges{
+		Activated: activations,
+		Exited:    exited,
+		Slashed:   slashings,
+	}
+	if err := s.beaconDB.SaveArchivedActiveValidatorChanges(ctx, prevEpoch, activeSetChanges); err != nil {
+		return errors.Wrap(err, "could not archive active validator set changes")
+	}
+	return nil
+}
+
+// We compute participation metrics by first retrieving the head state and
+// matching validator attestations during the epoch.
+func (s *Service) archiveParticipation(ctx context.Context, epoch uint64) error {
+	p := s.participationFetcher.Participation(epoch)
+	participation := &ethpb.ValidatorParticipation{}
+	if p != nil {
+		participation = &ethpb.ValidatorParticipation{
+			EligibleEther:           p.PrevEpoch,
+			VotedEther:              p.PrevEpochTargetAttesters,
+			GlobalParticipationRate: float32(p.PrevEpochTargetAttesters) / float32(p.PrevEpoch),
+		}
+	}
+	return s.beaconDB.SaveArchivedValidatorParticipation(ctx, epoch, participation)
+}
+
+// We archive validator balances and active indices.
+func (s *Service) archiveBalances(ctx context.Context, balances []uint64, epoch uint64) error {
+	if err := s.beaconDB.SaveArchivedBalances(ctx, epoch, balances); err != nil {
+		return errors.Wrap(err, "could not archive balances")
+	}
+	return nil
+}
+
+func (s *Service) run(ctx context.Context) {
+	stateChannel := make(chan *feed.Event, 1)
+	stateSub := s.stateNotifier.StateFeed().Subscribe(stateChannel)
+	defer stateSub.Unsubscribe()
+	for {
+		select {
+		case event := <-stateChannel:
+			if event.Type == statefeed.BlockProcessed {
+				data, ok := event.Data.(*statefeed.BlockProcessedData)
+				if !ok {
+					log.Error("Event feed data is not type *statefeed.BlockProcessedData")
+					continue
+				}
+				log.WithField("headRoot", fmt.Sprintf("%#x", data.BlockRoot)).Debug("Received block processed event")
+				headState, err := s.headFetcher.HeadState(ctx)
+				if err != nil {
+					log.WithError(err).Error("Head state is not available")
+					continue
+				}
+				slot := headState.Slot()
+				currentEpoch := helpers.SlotToEpoch(slot)
+				if !helpers.IsEpochEnd(slot) && currentEpoch <= s.lastArchivedEpoch {
+					continue
+				}
+				epochToArchive := currentEpoch
+				if !helpers.IsEpochEnd(slot) {
+					epochToArchive--
+				}
+				if err := s.archiveCommitteeInfo(ctx, headState, epochToArchive); err != nil {
+					log.WithError(err).Error("Could not archive committee info")
+					continue
+				}
+				if err := s.archiveActiveSetChanges(ctx, headState, epochToArchive); err != nil {
+					log.WithError(err).Error("Could not archive active validator set changes")
+					continue
+				}
+				if err := s.archiveParticipation(ctx, epochToArchive); err != nil {
+					log.WithError(err).Error("Could not archive validator participation")
+					continue
+				}
+				if err := s.archiveBalances(ctx, headState.Balances(), epochToArchive); err != nil {
+					log.WithError(err).Error("Could not archive validator balances and active indices")
+					continue
+				}
+				log.WithField(
+					"epoch",
+					epochToArchive,
+				).Debug("Successfully archived beacon chain data during epoch")
+				s.lastArchivedEpoch = epochToArchive
+			}
+		case <-s.ctx.Done():
+			log.Debug("Context closed, exiting goroutine")
+			return
+		case err := <-stateSub.Err():
+			log.WithError(err).Error("Subscription to state feed notifier failed")
+			return
+		}
+	}
+}