Ensure New State Type Tests Pass in Prysm

beacon-chain/archiver/BUILD.bazel

@@ -12,6 +12,7 @@ go_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",
@@ -32,6 +33,7 @@ go_test(
         "//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",

beacon-chain/archiver/service.go

@@ -12,6 +12,7 @@ import (
 	"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"
@@ -70,7 +71,7 @@ func (s *Service) Status() error {
 }
 
 // We archive committee information pertaining to the head state's epoch.
-func (s *Service) archiveCommitteeInfo(ctx context.Context, headState *pb.BeaconState, epoch uint64) error {
+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")
@@ -91,15 +92,16 @@ func (s *Service) archiveCommitteeInfo(ctx context.Context, headState *pb.Beacon
 }
 
 // We archive active validator set changes that happened during the previous epoch.
-func (s *Service) archiveActiveSetChanges(ctx context.Context, headState *pb.BeaconState, epoch uint64) error {
+func (s *Service) archiveActiveSetChanges(ctx context.Context, headState *state.BeaconState, epoch uint64) error {
 	prevEpoch := epoch - 1
-	activations := validators.ActivatedValidatorIndices(prevEpoch, headState.Validators)
-	slashings := validators.SlashedValidatorIndices(prevEpoch, headState.Validators)
+	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, headState.Validators, activeValidatorCount)
+	exited, err := validators.ExitedValidatorIndices(prevEpoch, vals, activeValidatorCount)
 	if err != nil {
 		return errors.Wrap(err, "could not determine exited validator indices")
 	}
@@ -130,8 +132,7 @@ func (s *Service) archiveParticipation(ctx context.Context, epoch uint64) error
 }
 
 // We archive validator balances and active indices.
-func (s *Service) archiveBalances(ctx context.Context, headState *pb.BeaconState, epoch uint64) error {
-	balances := headState.Balances
+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")
 	}
@@ -153,12 +154,13 @@ func (s *Service) run(ctx context.Context) {
 					log.WithError(err).Error("Head state is not available")
 					continue
 				}
-				currentEpoch := helpers.CurrentEpoch(headState)
-				if !helpers.IsEpochEnd(headState.Slot) && currentEpoch <= s.lastArchivedEpoch {
+				slot := headState.Slot()
+				currentEpoch := helpers.SlotToEpoch(slot)
+				if !helpers.IsEpochEnd(slot) && currentEpoch <= s.lastArchivedEpoch {
 					continue
 				}
 				epochToArchive := currentEpoch
-				if !helpers.IsEpochEnd(headState.Slot) {
+				if !helpers.IsEpochEnd(slot) {
 					epochToArchive--
 				}
 				if err := s.archiveCommitteeInfo(ctx, headState, epochToArchive); err != nil {
@@ -173,7 +175,7 @@ func (s *Service) run(ctx context.Context) {
 					log.WithError(err).Error("Could not archive validator participation")
 					continue
 				}
-				if err := s.archiveBalances(ctx, headState, epochToArchive); err != nil {
+				if err := s.archiveBalances(ctx, headState.Balances(), epochToArchive); err != nil {
 					log.WithError(err).Error("Could not archive validator balances and active indices")
 					continue
 				}

beacon-chain/archiver/service_test.go

@@ -17,6 +17,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	dbutil "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
@@ -27,15 +28,20 @@ import (
 func init() {
 	logrus.SetLevel(logrus.DebugLevel)
 	logrus.SetOutput(ioutil.Discard)
-	params.OverrideBeaconConfig(params.MinimalSpecConfig())
 }
 
 func TestArchiverService_ReceivesBlockProcessedEvent(t *testing.T) {
 	hook := logTest.NewGlobal()
 	svc, beaconDB := setupService(t)
 	defer dbutil.TeardownDB(t, beaconDB)
+	st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Slot: 1,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
 	svc.headFetcher = &mock.ChainService{
-		State: &pb.BeaconState{Slot: 1},
+		State: st,
 	}
 
 	event := &feed.Event{
@@ -55,8 +61,14 @@ func TestArchiverService_OnlyArchiveAtEpochEnd(t *testing.T) {
 	svc, beaconDB := setupService(t)
 	defer dbutil.TeardownDB(t, beaconDB)
 	// The head state is NOT an epoch end.
+	st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Slot: params.BeaconConfig().SlotsPerEpoch - 2,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
 	svc.headFetcher = &mock.ChainService{
-		State: &pb.BeaconState{Slot: params.BeaconConfig().SlotsPerEpoch - 2},
+		State: st,
 	}
 	event := &feed.Event{
 		Type: statefeed.BlockProcessed,
@@ -81,7 +93,10 @@ func TestArchiverService_ArchivesEvenThroughSkipSlot(t *testing.T) {
 	hook := logTest.NewGlobal()
 	svc, beaconDB := setupService(t)
 	validatorCount := uint64(100)
-	headState := setupState(validatorCount)
+	headState, err := setupState(validatorCount)
+	if err != nil {
+		t.Fatal(err)
+	}
 	defer dbutil.TeardownDB(t, beaconDB)
 	event := &feed.Event{
 		Type: statefeed.BlockProcessed,
@@ -99,7 +114,9 @@ func TestArchiverService_ArchivesEvenThroughSkipSlot(t *testing.T) {
 
 	// Send out an event every slot, skipping the end slot of the epoch.
 	for i := uint64(0); i < params.BeaconConfig().SlotsPerEpoch+1; i++ {
-		headState.Slot = i
+		if err := headState.SetSlot(i); err != nil {
+			t.Fatal(err)
+		}
 		svc.headFetcher = &mock.ChainService{
 			State: headState,
 		}
@@ -130,7 +147,10 @@ func TestArchiverService_ArchivesEvenThroughSkipSlot(t *testing.T) {
 func TestArchiverService_ComputesAndSavesParticipation(t *testing.T) {
 	hook := logTest.NewGlobal()
 	validatorCount := uint64(100)
-	headState := setupState(validatorCount)
+	headState, err := setupState(validatorCount)
+	if err != nil {
+		t.Fatal(err)
+	}
 	svc, beaconDB := setupService(t)
 	defer dbutil.TeardownDB(t, beaconDB)
 	svc.headFetcher = &mock.ChainService{
@@ -168,7 +188,10 @@ func TestArchiverService_ComputesAndSavesParticipation(t *testing.T) {
 func TestArchiverService_SavesIndicesAndBalances(t *testing.T) {
 	hook := logTest.NewGlobal()
 	validatorCount := uint64(100)
-	headState := setupState(validatorCount)
+	headState, err := setupState(validatorCount)
+	if err != nil {
+		t.Fatal(err)
+	}
 	svc, beaconDB := setupService(t)
 	defer dbutil.TeardownDB(t, beaconDB)
 	svc.headFetcher = &mock.ChainService{
@@ -187,11 +210,11 @@ func TestArchiverService_SavesIndicesAndBalances(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !reflect.DeepEqual(headState.Balances, retrieved) {
+	if !reflect.DeepEqual(headState.Balances(), retrieved) {
 		t.Errorf(
 			"Wanted balances for epoch %d %v, retrieved %v",
 			helpers.CurrentEpoch(headState),
-			headState.Balances,
+			headState.Balances(),
 			retrieved,
 		)
 	}
@@ -201,7 +224,10 @@ func TestArchiverService_SavesIndicesAndBalances(t *testing.T) {
 func TestArchiverService_SavesCommitteeInfo(t *testing.T) {
 	hook := logTest.NewGlobal()
 	validatorCount := uint64(100)
-	headState := setupState(validatorCount)
+	headState, err := setupState(validatorCount)
+	if err != nil {
+		t.Fatal(err)
+	}
 	svc, beaconDB := setupService(t)
 	defer dbutil.TeardownDB(t, beaconDB)
 	svc.headFetcher = &mock.ChainService{
@@ -248,16 +274,33 @@ func TestArchiverService_SavesCommitteeInfo(t *testing.T) {
 func TestArchiverService_SavesActivatedValidatorChanges(t *testing.T) {
 	hook := logTest.NewGlobal()
 	validatorCount := uint64(100)
-	headState := setupState(validatorCount)
+	headState, err := setupState(validatorCount)
+	if err != nil {
+		t.Fatal(err)
+	}
 	svc, beaconDB := setupService(t)
 	defer dbutil.TeardownDB(t, beaconDB)
 	svc.headFetcher = &mock.ChainService{
 		State: headState,
 	}
 	prevEpoch := helpers.PrevEpoch(headState)
 	delayedActEpoch := helpers.DelayedActivationExitEpoch(prevEpoch)
-	headState.Validators[4].ActivationEpoch = delayedActEpoch
-	headState.Validators[5].ActivationEpoch = delayedActEpoch
+	val1, err := headState.ValidatorAtIndex(4)
+	if err != nil {
+		t.Fatal(err)
+	}
+	val1.ActivationEpoch = delayedActEpoch
+	val2, err := headState.ValidatorAtIndex(5)
+	if err != nil {
+		t.Fatal(err)
+	}
+	val2.ActivationEpoch = delayedActEpoch
+	if err := headState.UpdateValidatorAtIndex(4, val1); err != nil {
+		t.Fatal(err)
+	}
+	if err := headState.UpdateValidatorAtIndex(5, val1); err != nil {
+		t.Fatal(err)
+	}
 	event := &feed.Event{
 		Type: statefeed.BlockProcessed,
 		Data: &statefeed.BlockProcessedData{
@@ -283,15 +326,32 @@ func TestArchiverService_SavesActivatedValidatorChanges(t *testing.T) {
 func TestArchiverService_SavesSlashedValidatorChanges(t *testing.T) {
 	hook := logTest.NewGlobal()
 	validatorCount := uint64(100)
-	headState := setupState(validatorCount)
+	headState, err := setupState(validatorCount)
+	if err != nil {
+		t.Fatal(err)
+	}
 	svc, beaconDB := setupService(t)
 	defer dbutil.TeardownDB(t, beaconDB)
 	svc.headFetcher = &mock.ChainService{
 		State: headState,
 	}
 	prevEpoch := helpers.PrevEpoch(headState)
-	headState.Validators[95].Slashed = true
-	headState.Validators[96].Slashed = true
+	val1, err := headState.ValidatorAtIndex(95)
+	if err != nil {
+		t.Fatal(err)
+	}
+	val1.Slashed = true
+	val2, err := headState.ValidatorAtIndex(96)
+	if err != nil {
+		t.Fatal(err)
+	}
+	val2.Slashed = true
+	if err := headState.UpdateValidatorAtIndex(95, val1); err != nil {
+		t.Fatal(err)
+	}
+	if err := headState.UpdateValidatorAtIndex(96, val1); err != nil {
+		t.Fatal(err)
+	}
 	event := &feed.Event{
 		Type: statefeed.BlockProcessed,
 		Data: &statefeed.BlockProcessedData{
@@ -317,15 +377,25 @@ func TestArchiverService_SavesSlashedValidatorChanges(t *testing.T) {
 func TestArchiverService_SavesExitedValidatorChanges(t *testing.T) {
 	hook := logTest.NewGlobal()
 	validatorCount := uint64(100)
-	headState := setupState(validatorCount)
+	headState, err := setupState(validatorCount)
+	if err != nil {
+		t.Fatal(err)
+	}
 	svc, beaconDB := setupService(t)
 	defer dbutil.TeardownDB(t, beaconDB)
 	svc.headFetcher = &mock.ChainService{
 		State: headState,
 	}
 	prevEpoch := helpers.PrevEpoch(headState)
-	headState.Validators[95].ExitEpoch = prevEpoch
-	headState.Validators[95].WithdrawableEpoch = prevEpoch + params.BeaconConfig().MinValidatorWithdrawabilityDelay
+	val, err := headState.ValidatorAtIndex(95)
+	if err != nil {
+		t.Fatal(err)
+	}
+	val.ExitEpoch = prevEpoch
+	val.WithdrawableEpoch = prevEpoch + params.BeaconConfig().MinValidatorWithdrawabilityDelay
+	if err := headState.UpdateValidatorAtIndex(95, val); err != nil {
+		t.Fatal(err)
+	}
 	event := &feed.Event{
 		Type: statefeed.BlockProcessed,
 		Data: &statefeed.BlockProcessedData{
@@ -347,7 +417,7 @@ func TestArchiverService_SavesExitedValidatorChanges(t *testing.T) {
 	}
 }
 
-func setupState(validatorCount uint64) *pb.BeaconState {
+func setupState(validatorCount uint64) (*stateTrie.BeaconState, error) {
 	validators := make([]*ethpb.Validator, validatorCount)
 	balances := make([]uint64, validatorCount)
 	for i := 0; i < len(validators); i++ {
@@ -363,18 +433,18 @@ func setupState(validatorCount uint64) *pb.BeaconState {
 
 	// We initialize a head state that has attestations from participated
 	// validators in a simulated fashion.
-	return &pb.BeaconState{
+	return stateTrie.InitializeFromProto(&pb.BeaconState{
 		Slot:                       (2 * params.BeaconConfig().SlotsPerEpoch) - 1,
 		Validators:                 validators,
 		Balances:                   balances,
-		BlockRoots:                 make([][]byte, 128),
+		BlockRoots:                 make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot),
 		Slashings:                  []uint64{0, 1e9, 1e9},
 		RandaoMixes:                make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 		CurrentEpochAttestations:   atts,
 		FinalizedCheckpoint:        &ethpb.Checkpoint{},
 		JustificationBits:          bitfield.Bitvector4{0x00},
 		CurrentJustifiedCheckpoint: &ethpb.Checkpoint{},
-	}
+	})
 }
 
 func setupService(t *testing.T) (*Service, db.Database) {

beacon-chain/blockchain/BUILD.bazel

@@ -35,13 +35,13 @@ go_library(
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/powchain:go_default_library",
+        "//beacon-chain/state:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/attestationutil:go_default_library",
         "//shared/bytesutil:go_default_library",
         "//shared/featureconfig:go_default_library",
         "//shared/params:go_default_library",
         "//shared/slotutil:go_default_library",
-        "//shared/stateutil:go_default_library",
         "//shared/traceutil:go_default_library",
         "@com_github_emicklei_dot//:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",