Recursively Find Validator Database File In Slashing Protection Commands (#8518)

* issue/feature 8500 find validator.db automatically

* gazelle build

* remove less! why there?

* fixed errors import

* fixed errors import

* unit tested

* adding the find validator.db fileutil func to export and import slashing

* deleted the comment

Co-authored-by: Raul Jordan <raul@prysmaticlabs.com>

.deepsource.toml

@@ -1,11 +1,13 @@
 version = 1
 
+exclude_patterns = ["tools/analyzers/**"]
+
 [[analyzers]]
 name = "go"
 enabled = true
 
-  [analyzers.meta]
-  import_paths = ["github.com/prysmaticlabs/prysm"]
+[analyzers.meta]
+import_paths = ["github.com/prysmaticlabs/prysm"]
 
 [[analyzers]]
 name = "test-coverage"
@@ -14,3 +16,7 @@ enabled = true
 [[analyzers]]
 name = "shell"
 enabled = true
+
+[[analyzers]]
+name = "secrets"
+enabled = true

WORKSPACE

@@ -60,10 +60,10 @@ bazel_skylib_workspace()
 
 http_archive(
     name = "bazel_gazelle",
-    sha256 = "1f4fc1d91826ec436ae04833430626f4cc02c20bb0a813c0c2f3c4c421307b1d",
-    strip_prefix = "bazel-gazelle-e368a11b76e92932122d824970dc0ce5feb9c349",
+    sha256 = "222e49f034ca7a1d1231422cdb67066b885819885c356673cb1f72f748a3c9d4",
     urls = [
-        "https://github.com/bazelbuild/bazel-gazelle/archive/e368a11b76e92932122d824970dc0ce5feb9c349.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.22.3/bazel-gazelle-v0.22.3.tar.gz",
+        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.22.3/bazel-gazelle-v0.22.3.tar.gz",
     ],
 )
 
@@ -89,10 +89,10 @@ http_archive(
         # nogo check fails for certain third_party dependencies.
         "//third_party:io_bazel_rules_go.patch",
     ],
-    sha256 = "dbf5a9ef855684f84cac2e7ae7886c5a001d4f66ae23f6904da0faaaef0d61fc",
+    sha256 = "52d0a57ea12139d727883c2fef03597970b89f2cc2a05722c42d1d7d41ec065b",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.24.11/rules_go-v0.24.11.tar.gz",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.24.11/rules_go-v0.24.11.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.24.13/rules_go-v0.24.13.tar.gz",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.24.13/rules_go-v0.24.13.tar.gz",
     ],
 )
 
@@ -156,7 +156,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.15.7",
+    go_version = "1.16",
     nogo = "@//:nogo",
 )
 

beacon-chain/blockchain/BUILD.bazel

@@ -59,6 +59,7 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -4,15 +4,15 @@ import (
 	"context"
 	"time"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
+	"go.opencensus.io/trace"
 )
 
 // ChainInfoFetcher defines a common interface for methods in blockchain service which
@@ -27,7 +27,7 @@ type ChainInfoFetcher interface {
 // TimeFetcher retrieves the Eth2 data that's related to time.
 type TimeFetcher interface {
 	GenesisTime() time.Time
-	CurrentSlot() uint64
+	CurrentSlot() types.Slot
 }
 
 // GenesisFetcher retrieves the eth2 data related to its genesis.
@@ -38,12 +38,12 @@ type GenesisFetcher interface {
 // HeadFetcher defines a common interface for methods in blockchain service which
 // directly retrieves head related data.
 type HeadFetcher interface {
-	HeadSlot() uint64
+	HeadSlot() types.Slot
 	HeadRoot(ctx context.Context) ([]byte, error)
 	HeadBlock(ctx context.Context) (*ethpb.SignedBeaconBlock, error)
 	HeadState(ctx context.Context) (*state.BeaconState, error)
-	HeadValidatorsIndices(ctx context.Context, epoch uint64) ([]uint64, error)
-	HeadSeed(ctx context.Context, epoch uint64) ([32]byte, error)
+	HeadValidatorsIndices(ctx context.Context, epoch types.Epoch) ([]types.ValidatorIndex, error)
+	HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, error)
 	HeadGenesisValidatorRoot() [32]byte
 	HeadETH1Data() *ethpb.Eth1Data
 	ProtoArrayStore() *protoarray.Store
@@ -96,7 +96,7 @@ func (s *Service) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
 }
 
 // HeadSlot returns the slot of the head of the chain.
-func (s *Service) HeadSlot() uint64 {
+func (s *Service) HeadSlot() types.Slot {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
@@ -167,18 +167,18 @@ func (s *Service) HeadState(ctx context.Context) (*state.BeaconState, error) {
 }
 
 // HeadValidatorsIndices returns a list of active validator indices from the head view of a given epoch.
-func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch uint64) ([]uint64, error) {
+func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch types.Epoch) ([]types.ValidatorIndex, error) {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
 	if !s.hasHeadState() {
-		return []uint64{}, nil
+		return []types.ValidatorIndex{}, nil
 	}
 	return helpers.ActiveValidatorIndices(s.headState(ctx), epoch)
 }
 
 // HeadSeed returns the seed from the head view of a given epoch.
-func (s *Service) HeadSeed(ctx context.Context, epoch uint64) ([32]byte, error) {
+func (s *Service) HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, error) {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 

beacon-chain/blockchain/chain_info_test.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/gogo/protobuf/proto"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
@@ -106,7 +107,7 @@ func TestHeadSlot_CanRetrieve(t *testing.T) {
 	s, err := state.InitializeFromProto(&pb.BeaconState{})
 	require.NoError(t, err)
 	c.head = &head{slot: 100, state: s}
-	assert.Equal(t, uint64(100), c.HeadSlot())
+	assert.Equal(t, types.Slot(100), c.HeadSlot())
 }
 
 func TestHeadRoot_CanRetrieve(t *testing.T) {

beacon-chain/blockchain/head.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
@@ -20,7 +21,7 @@ import (
 
 // This defines the current chain service's view of head.
 type head struct {
-	slot  uint64                   // current head slot.
+	slot  types.Slot               // current head slot.
 	root  [32]byte                 // current head root.
 	block *ethpb.SignedBeaconBlock // current head block.
 	state *stateTrie.BeaconState   // current head state.
@@ -148,6 +149,9 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 // root in DB. With the inception of initial-sync-cache-state flag, it uses finalized
 // check point as anchors to resume sync therefore head is no longer needed to be saved on per slot basis.
 func (s *Service) saveHeadNoDB(ctx context.Context, b *ethpb.SignedBeaconBlock, r [32]byte, hs *stateTrie.BeaconState) error {
+	if err := helpers.VerifyNilBeaconBlock(b); err != nil {
+		return err
+	}
 	cachedHeadRoot, err := s.HeadRoot(ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get head root from cache")
@@ -156,10 +160,6 @@ func (s *Service) saveHeadNoDB(ctx context.Context, b *ethpb.SignedBeaconBlock,
 		return nil
 	}
 
-	if b == nil || b.Block == nil {
-		return errors.New("cannot save nil head block")
-	}
-
 	s.setHeadInitialSync(r, stateTrie.CopySignedBeaconBlock(b), hs)
 	return nil
 }
@@ -196,7 +196,7 @@ func (s *Service) setHeadInitialSync(root [32]byte, block *ethpb.SignedBeaconBlo
 
 // This returns the head slot.
 // This is a lock free version.
-func (s *Service) headSlot() uint64 {
+func (s *Service) headSlot() types.Slot {
 	return s.head.slot
 }
 

beacon-chain/blockchain/head_test.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -22,7 +23,7 @@ func TestSaveHead_Same(t *testing.T) {
 	service.head = &head{slot: 0, root: r}
 
 	require.NoError(t, service.saveHead(context.Background(), r))
-	assert.Equal(t, uint64(0), service.headSlot(), "Head did not stay the same")
+	assert.Equal(t, types.Slot(0), service.headSlot(), "Head did not stay the same")
 	assert.Equal(t, r, service.headRoot(), "Head did not stay the same")
 }
 
@@ -48,7 +49,7 @@ func TestSaveHead_Different(t *testing.T) {
 	require.NoError(t, service.beaconDB.SaveState(context.Background(), headState, newRoot))
 	require.NoError(t, service.saveHead(context.Background(), newRoot))
 
-	assert.Equal(t, uint64(1), service.HeadSlot(), "Head did not change")
+	assert.Equal(t, types.Slot(1), service.HeadSlot(), "Head did not change")
 
 	cachedRoot, err := service.HeadRoot(context.Background())
 	require.NoError(t, err)
@@ -82,7 +83,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	require.NoError(t, service.beaconDB.SaveState(context.Background(), headState, newRoot))
 	require.NoError(t, service.saveHead(context.Background(), newRoot))
 
-	assert.Equal(t, uint64(1), service.HeadSlot(), "Head did not change")
+	assert.Equal(t, types.Slot(1), service.HeadSlot(), "Head did not change")
 
 	cachedRoot, err := service.HeadRoot(context.Background())
 	require.NoError(t, err)

beacon-chain/blockchain/info_test.go

@@ -33,7 +33,7 @@ func TestService_TreeHandler(t *testing.T) {
 		),
 		StateGen: stategen.New(beaconDB),
 	}
-	s, err := New(ctx, cfg)
+	s, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	require.NoError(t, s.forkChoiceStore.ProcessBlock(ctx, 0, [32]byte{'a'}, [32]byte{'g'}, [32]byte{'c'}, 0, 0))
 	require.NoError(t, s.forkChoiceStore.ProcessBlock(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'c'}, 0, 0))

beacon-chain/blockchain/log.go

@@ -3,10 +3,12 @@ package blockchain
 import (
 	"encoding/hex"
 	"fmt"
+	"time"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
 	"github.com/sirupsen/logrus"
 )
 
@@ -14,16 +16,30 @@ var log = logrus.WithField("prefix", "blockchain")
 
 // logs state transition related data every slot.
 func logStateTransitionData(b *ethpb.BeaconBlock) {
-	log.WithFields(logrus.Fields{
-		"attestations":      len(b.Body.Attestations),
-		"deposits":          len(b.Body.Deposits),
-		"attesterSlashings": len(b.Body.AttesterSlashings),
-		"proposerSlashings": len(b.Body.ProposerSlashings),
-		"voluntaryExits":    len(b.Body.VoluntaryExits),
-	}).Info("Finished applying state transition")
+	log := log.WithField("slot", b.Slot)
+	if len(b.Body.Attestations) > 0 {
+		log = log.WithField("attestations", len(b.Body.Attestations))
+	}
+	if len(b.Body.Deposits) > 0 {
+		log = log.WithField("deposits", len(b.Body.Deposits))
+	}
+	if len(b.Body.AttesterSlashings) > 0 {
+		log = log.WithField("attesterSlashings", len(b.Body.AttesterSlashings))
+	}
+	if len(b.Body.ProposerSlashings) > 0 {
+		log = log.WithField("proposerSlashings", len(b.Body.ProposerSlashings))
+	}
+	if len(b.Body.VoluntaryExits) > 0 {
+		log = log.WithField("voluntaryExits", len(b.Body.VoluntaryExits))
+	}
+	log.Info("Finished applying state transition")
 }
 
-func logBlockSyncStatus(block *ethpb.BeaconBlock, blockRoot [32]byte, finalized *ethpb.Checkpoint) {
+func logBlockSyncStatus(block *ethpb.BeaconBlock, blockRoot [32]byte, finalized *ethpb.Checkpoint, receivedTime time.Time, genesisTime uint64) error {
+	startTime, err := helpers.SlotToTime(genesisTime, block.Slot)
+	if err != nil {
+		return err
+	}
 	log.WithFields(logrus.Fields{
 		"slot":           block.Slot,
 		"slotInEpoch":    block.Slot % params.BeaconConfig().SlotsPerEpoch,
@@ -32,4 +48,10 @@ func logBlockSyncStatus(block *ethpb.BeaconBlock, blockRoot [32]byte, finalized
 		"finalizedEpoch": finalized.Epoch,
 		"finalizedRoot":  fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
 	}).Info("Synced new block")
+	log.WithFields(logrus.Fields{
+		"slot":                      block.Slot,
+		"sinceSlotStartTime":        timeutils.Now().Sub(startTime),
+		"chainServiceProcessedTime": timeutils.Now().Sub(receivedTime),
+	}).Debug("Sync new block times")
+	return nil
 }

beacon-chain/blockchain/log_test.go

@@ -0,0 +1,63 @@
+package blockchain
+
+import (
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	logTest "github.com/sirupsen/logrus/hooks/test"
+)
+
+func Test_logStateTransitionData(t *testing.T) {
+	tests := []struct {
+		name string
+		b    *ethpb.BeaconBlock
+		want string
+	}{
+		{name: "empty block body",
+			b:    &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}},
+			want: "\"Finished applying state transition\" prefix=blockchain slot=0",
+		},
+		{name: "has attestation",
+			b:    &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{Attestations: []*ethpb.Attestation{{}}}},
+			want: "\"Finished applying state transition\" attestations=1 prefix=blockchain slot=0",
+		},
+		{name: "has deposit",
+			b: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				Attestations: []*ethpb.Attestation{{}},
+				Deposits:     []*ethpb.Deposit{{}}}},
+			want: "\"Finished applying state transition\" attestations=1 deposits=1 prefix=blockchain slot=0",
+		},
+		{name: "has attester slashing",
+			b: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				AttesterSlashings: []*ethpb.AttesterSlashing{{}}}},
+			want: "\"Finished applying state transition\" attesterSlashings=1 prefix=blockchain slot=0",
+		},
+		{name: "has proposer slashing",
+			b: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				ProposerSlashings: []*ethpb.ProposerSlashing{{}}}},
+			want: "\"Finished applying state transition\" prefix=blockchain proposerSlashings=1 slot=0",
+		},
+		{name: "has exit",
+			b: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				VoluntaryExits: []*ethpb.SignedVoluntaryExit{{}}}},
+			want: "\"Finished applying state transition\" prefix=blockchain slot=0 voluntaryExits=1",
+		},
+		{name: "has everything",
+			b: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				Attestations:      []*ethpb.Attestation{{}},
+				Deposits:          []*ethpb.Deposit{{}},
+				AttesterSlashings: []*ethpb.AttesterSlashing{{}},
+				ProposerSlashings: []*ethpb.ProposerSlashing{{}},
+				VoluntaryExits:    []*ethpb.SignedVoluntaryExit{{}}}},
+			want: "\"Finished applying state transition\" attestations=1 attesterSlashings=1 deposits=1 prefix=blockchain proposerSlashings=1 slot=0 voluntaryExits=1",
+		},
+	}
+	for _, tt := range tests {
+		hook := logTest.NewGlobal()
+		t.Run(tt.name, func(t *testing.T) {
+			logStateTransitionData(tt.b)
+			require.LogsContain(t, hook, tt.want)
+		})
+	}
+}

beacon-chain/blockchain/metrics.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -108,7 +109,7 @@ var (
 )
 
 // reportSlotMetrics reports slot related metrics.
-func reportSlotMetrics(stateSlot, headSlot, clockSlot uint64, finalizedCheckpoint *ethpb.Checkpoint) {
+func reportSlotMetrics(stateSlot, headSlot, clockSlot types.Slot, finalizedCheckpoint *ethpb.Checkpoint) {
 	clockTimeSlot.Set(float64(clockSlot))
 	beaconSlot.Set(float64(stateSlot))
 	beaconHeadSlot.Set(float64(headSlot))
@@ -120,7 +121,7 @@ func reportSlotMetrics(stateSlot, headSlot, clockSlot uint64, finalizedCheckpoin
 
 // reportEpochMetrics reports epoch related metrics.
 func reportEpochMetrics(ctx context.Context, postState, headState *stateTrie.BeaconState) error {
-	currentEpoch := postState.Slot() / params.BeaconConfig().SlotsPerEpoch
+	currentEpoch := types.Epoch(postState.Slot() / params.BeaconConfig().SlotsPerEpoch)
 
 	// Validator instances
 	pendingInstances := 0
@@ -139,7 +140,7 @@ func reportEpochMetrics(ctx context.Context, postState, headState *stateTrie.Bea
 	slashingEffectiveBalance := uint64(0)
 
 	for i, validator := range postState.Validators() {
-		bal, err := postState.BalanceAtIndex(uint64(i))
+		bal, err := postState.BalanceAtIndex(types.ValidatorIndex(i))
 		if err != nil {
 			log.Errorf("Could not load validator balance: %v", err)
 			continue

beacon-chain/blockchain/process_attestation_helpers.go

@@ -6,11 +6,13 @@ import (
 	"strconv"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/mputil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
@@ -19,7 +21,7 @@ import (
 func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (*stateTrie.BeaconState, error) {
 	// Use a multilock to allow scoped holding of a mutex by a checkpoint root + epoch
 	// allowing us to behave smarter in terms of how this function is used concurrently.
-	epochKey := strconv.FormatUint(c.Epoch, 10 /* base 10 */)
+	epochKey := strconv.FormatUint(uint64(c.Epoch), 10 /* base 10 */)
 	lock := mputil.NewMultilock(string(c.Root) + epochKey)
 	lock.Lock()
 	defer lock.Unlock()
@@ -41,9 +43,16 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (*sta
 		return nil, err
 	}
 	if epochStartSlot > baseState.Slot() {
-		baseState, err = state.ProcessSlots(ctx, baseState, epochStartSlot)
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
+		if featureconfig.Get().EnableNextSlotStateCache {
+			baseState, err = state.ProcessSlotsUsingNextSlotCache(ctx, baseState, c.Root, epochStartSlot)
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
+			}
+		} else {
+			baseState, err = state.ProcessSlots(ctx, baseState, epochStartSlot)
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
+			}
 		}
 		if err := s.checkpointStateCache.AddCheckpointState(c, baseState); err != nil {
 			return nil, errors.Wrap(err, "could not saved checkpoint state to cache")
@@ -68,9 +77,9 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (*sta
 
 // verifyAttTargetEpoch validates attestation is from the current or previous epoch.
 func (s *Service) verifyAttTargetEpoch(_ context.Context, genesisTime, nowTime uint64, c *ethpb.Checkpoint) error {
-	currentSlot := (nowTime - genesisTime) / params.BeaconConfig().SecondsPerSlot
+	currentSlot := types.Slot((nowTime - genesisTime) / params.BeaconConfig().SecondsPerSlot)
 	currentEpoch := helpers.SlotToEpoch(currentSlot)
-	var prevEpoch uint64
+	var prevEpoch types.Epoch
 	// Prevents previous epoch under flow
 	if currentEpoch > 1 {
 		prevEpoch = currentEpoch - 1
@@ -93,8 +102,8 @@ func (s *Service) verifyBeaconBlock(ctx context.Context, data *ethpb.Attestation
 	if b == nil && s.hasInitSyncBlock(r) {
 		b = s.getInitSyncBlock(r)
 	}
-	if b == nil || b.Block == nil {
-		return fmt.Errorf("beacon block %#x does not exist", bytesutil.Trunc(data.BeaconBlockRoot))
+	if err := helpers.VerifyNilBeaconBlock(b); err != nil {
+		return err
 	}
 	if b.Block.Slot > data.Slot {
 		return fmt.Errorf("could not process attestation for future block, block.Slot=%d > attestation.Data.Slot=%d", b.Block.Slot, data.Slot)

beacon-chain/blockchain/process_attestation_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
@@ -29,7 +30,7 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
 		StateGen:        stategen.New(beaconDB),
 	}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	_, err = blockTree1(t, beaconDB, []byte{'g'})
@@ -135,7 +136,7 @@ func TestStore_OnAttestation_Ok(t *testing.T) {
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
 		StateGen:        stategen.New(beaconDB),
 	}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	genesisState, pks := testutil.DeterministicGenesisState(t, 64)
 	require.NoError(t, genesisState.SetGenesisTime(uint64(timeutils.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
@@ -159,7 +160,7 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 		BeaconDB: beaconDB,
 		StateGen: stategen.New(beaconDB),
 	}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	s, err := testutil.NewBeaconState()
@@ -231,22 +232,22 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 		BeaconDB: beaconDB,
 		StateGen: stategen.New(beaconDB),
 	}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	epoch := uint64(1)
+	epoch := types.Epoch(1)
 	baseState, _ := testutil.DeterministicGenesisState(t, 1)
 	checkpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("hi"), 32)}
 	require.NoError(t, service.beaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)))
 	returned, err := service.getAttPreState(ctx, checkpoint)
 	require.NoError(t, err)
-	assert.Equal(t, returned.Slot(), checkpoint.Epoch*params.BeaconConfig().SlotsPerEpoch, "Incorrectly returned base state")
+	assert.Equal(t, params.BeaconConfig().SlotsPerEpoch.Mul(uint64(checkpoint.Epoch)), returned.Slot(), "Incorrectly returned base state")
 
 	cached, err := service.checkpointStateCache.StateByCheckpoint(checkpoint)
 	require.NoError(t, err)
 	assert.Equal(t, returned.Slot(), cached.Slot(), "State should have been cached")
 
-	epoch = uint64(2)
+	epoch = 2
 	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("bye"), 32)}
 	require.NoError(t, service.beaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(newCheckpoint.Root)))
 	returned, err = service.getAttPreState(ctx, newCheckpoint)
@@ -269,10 +270,10 @@ func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	nowTime := params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot
+	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)}))
 }
 
@@ -281,10 +282,10 @@ func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	nowTime := params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot
+	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Epoch: 1}))
 }
 
@@ -293,10 +294,10 @@ func TestAttEpoch_NotMatch(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	nowTime := 2 * params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot
+	nowTime := 2 * uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	err = service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)})
 	assert.ErrorContains(t, "target epoch 0 does not match current epoch 2 or prev epoch 1", err)
 }
@@ -306,11 +307,11 @@ func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	d := testutil.HydrateAttestationData(&ethpb.AttestationData{})
-	assert.ErrorContains(t, "beacon block 0x000000000000 does not exist", service.verifyBeaconBlock(ctx, d))
+	assert.ErrorContains(t, "signed beacon block can't be nil", service.verifyBeaconBlock(ctx, d))
 }
 
 func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
@@ -318,7 +319,7 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	b := testutil.NewBeaconBlock()
@@ -336,7 +337,7 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	b := testutil.NewBeaconBlock()
@@ -354,7 +355,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	b32 := testutil.NewBeaconBlock()
@@ -381,7 +382,7 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	b32 := testutil.NewBeaconBlock()
@@ -408,7 +409,7 @@ func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	b32 := testutil.NewBeaconBlock()

beacon-chain/blockchain/process_block.go

@@ -7,6 +7,8 @@ import (
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"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/state"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -22,8 +24,11 @@ import (
 // A custom slot deadline for processing state slots in our cache.
 const slotDeadline = 5 * time.Second
 
+// A custom deadline for deposit trie insertion.
+const depositDeadline = 20 * time.Second
+
 // This defines size of the upper bound for initial sync block cache.
-var initialSyncBlockCacheSize = 2 * params.BeaconConfig().SlotsPerEpoch
+var initialSyncBlockCacheSize = uint64(2 * params.BeaconConfig().SlotsPerEpoch)
 
 // onBlock is called when a gossip block is received. It runs regular state transition on the block.
 // The block's signing root should be computed before calling this method to avoid redundant
@@ -126,42 +131,56 @@ func (s *Service) onBlock(ctx context.Context, signed *ethpb.SignedBeaconBlock,
 		}
 	}
 
-	// Update finalized check point.
-	if postState.FinalizedCheckpointEpoch() > s.finalizedCheckpt.Epoch {
-		if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
-			return err
+	newFinalized := postState.FinalizedCheckpointEpoch() > s.finalizedCheckpt.Epoch
+	if featureconfig.Get().UpdateHeadTimely {
+		if newFinalized {
+			if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
+				return errors.Wrap(err, "could not save new justified")
+			}
+			s.prevFinalizedCheckpt = s.finalizedCheckpt
+			s.finalizedCheckpt = postState.FinalizedCheckpoint()
 		}
-		s.clearInitSyncBlocks()
 
+		if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
+			log.WithError(err).Warn("Could not update head")
+		}
+
+		// Send notification of the processed block to the state feed.
+		s.stateNotifier.StateFeed().Send(&feed.Event{
+			Type: statefeed.BlockProcessed,
+			Data: &statefeed.BlockProcessedData{
+				Slot:        signed.Block.Slot,
+				BlockRoot:   blockRoot,
+				SignedBlock: signed,
+				Verified:    true,
+			},
+		})
+	}
+
+	// Update finalized check point.
+	if newFinalized {
 		if err := s.updateFinalized(ctx, postState.FinalizedCheckpoint()); err != nil {
 			return err
 		}
-
 		fRoot := bytesutil.ToBytes32(postState.FinalizedCheckpoint().Root)
 		if err := s.forkChoiceStore.Prune(ctx, fRoot); err != nil {
 			return errors.Wrap(err, "could not prune proto array fork choice nodes")
 		}
-
-		if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
-			return errors.Wrap(err, "could not save new justified")
-		}
-
-		// Update deposit cache.
-		finalizedState, err := s.stateGen.StateByRoot(ctx, fRoot)
-		if err != nil {
-			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 := int64(finalizedState.Eth1Data().DepositCount - 1)
-		s.depositCache.InsertFinalizedDeposits(ctx, eth1DepositIndex)
-		if featureconfig.Get().EnablePruningDepositProofs {
-			// Deposit proofs are only used during state transition and can be safely removed to save space.
-			if err = s.depositCache.PruneProofs(ctx, eth1DepositIndex); err != nil {
-				return errors.Wrap(err, "could not prune deposit proofs")
+		if !featureconfig.Get().UpdateHeadTimely {
+			if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
+				return errors.Wrap(err, "could not save new justified")
 			}
 		}
+		go func() {
+			// Use a custom deadline here, since this method runs asynchronously.
+			// We ignore the parent method's context and instead create a new one
+			// with a custom deadline, therefore using the background context instead.
+			depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline)
+			defer cancel()
+			if err := s.insertFinalizedDeposits(depCtx, fRoot); err != nil {
+				log.WithError(err).Error("Could not insert finalized deposits.")
+			}
+		}()
 	}
 
 	defer reportAttestationInclusion(b)
@@ -169,75 +188,6 @@ func (s *Service) onBlock(ctx context.Context, signed *ethpb.SignedBeaconBlock,
 	return s.handleEpochBoundary(ctx, postState)
 }
 
-// onBlockInitialSyncStateTransition is called when an initial sync block is received.
-// It runs state transition on the block and without fork choice and post operation pool processes.
-// The block's signing root should be computed before calling this method to avoid redundant
-// computation in this method and methods it calls into.
-func (s *Service) onBlockInitialSyncStateTransition(ctx context.Context, signed *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockInitialSyncStateTransition")
-	defer span.End()
-
-	if signed == nil || signed.Block == nil {
-		return errors.New("nil block")
-	}
-
-	b := signed.Block
-
-	// Retrieve incoming block's pre state.
-	if err := s.verifyBlkPreState(ctx, b); err != nil {
-		return err
-	}
-
-	preState, err := s.stateGen.StateByRootInitialSync(ctx, bytesutil.ToBytes32(signed.Block.ParentRoot))
-	if err != nil {
-		return err
-	}
-	if preState == nil {
-		return fmt.Errorf("nil pre state for slot %d", b.Slot)
-	}
-
-	// Exit early if the pre state slot is higher than incoming block's slot.
-	if preState.Slot() >= signed.Block.Slot {
-		return nil
-	}
-
-	postState, err := state.ExecuteStateTransition(ctx, preState, signed)
-	if err != nil {
-		return errors.Wrap(err, "could not execute state transition")
-	}
-
-	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState, true /* init sync */); err != nil {
-		return err
-	}
-	// Save the latest block as head in cache.
-	if err := s.saveHeadNoDB(ctx, signed, blockRoot, postState); err != nil {
-		return err
-	}
-
-	// Rate limit how many blocks (2 epochs worth of blocks) a node keeps in the memory.
-	if uint64(len(s.getInitSyncBlocks())) > initialSyncBlockCacheSize {
-		if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
-			return err
-		}
-		s.clearInitSyncBlocks()
-	}
-
-	if postState.CurrentJustifiedCheckpoint().Epoch > s.justifiedCheckpt.Epoch {
-		if err := s.updateJustifiedInitSync(ctx, postState.CurrentJustifiedCheckpoint()); err != nil {
-			return err
-		}
-	}
-
-	// Update finalized check point. Prune the block cache and helper caches on every new finalized epoch.
-	if postState.FinalizedCheckpointEpoch() > s.finalizedCheckpt.Epoch {
-		if err := s.updateFinalized(ctx, postState.FinalizedCheckpoint()); err != nil {
-			return err
-		}
-	}
-
-	return s.handleEpochBoundary(ctx, postState)
-}
-
 func (s *Service) onBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBlock,
 	blockRoots [][32]byte) ([]*ethpb.Checkpoint, []*ethpb.Checkpoint, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockBatch")
@@ -359,7 +309,12 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState *stateTrie.
 		if err := helpers.UpdateCommitteeCache(postState, helpers.NextEpoch(postState)); err != nil {
 			return err
 		}
-		if err := helpers.UpdateProposerIndicesInCache(postState, helpers.NextEpoch(postState)); err != nil {
+		copied := postState.Copy()
+		copied, err := state.ProcessSlots(ctx, copied, copied.Slot()+1)
+		if err != nil {
+			return err
+		}
+		if err := helpers.UpdateProposerIndicesInCache(copied); err != nil {
 			return err
 		}
 	} else if postState.Slot() >= s.nextEpochBoundarySlot {
@@ -377,7 +332,7 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState *stateTrie.
 		if err := helpers.UpdateCommitteeCache(postState, helpers.CurrentEpoch(postState)); err != nil {
 			return err
 		}
-		if err := helpers.UpdateProposerIndicesInCache(postState, helpers.CurrentEpoch(postState)); err != nil {
+		if err := helpers.UpdateProposerIndicesInCache(postState); err != nil {
 			return err
 		}
 	}

beacon-chain/blockchain/process_block_helpers.go

@@ -6,18 +6,20 @@ import (
 	"fmt"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/attestationutil"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/traceutil"
 	"go.opencensus.io/trace"
 )
 
 // CurrentSlot returns the current slot based on time.
-func (s *Service) CurrentSlot() uint64 {
+func (s *Service) CurrentSlot() types.Slot {
 	return helpers.CurrentSlot(uint64(s.genesisTime.Unix()))
 }
 
@@ -230,9 +232,10 @@ func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) err
 	if err := s.beaconDB.SaveFinalizedCheckpoint(ctx, cp); err != nil {
 		return err
 	}
-
-	s.prevFinalizedCheckpt = s.finalizedCheckpt
-	s.finalizedCheckpt = cp
+	if !featureconfig.Get().UpdateHeadTimely {
+		s.prevFinalizedCheckpt = s.finalizedCheckpt
+		s.finalizedCheckpt = cp
+	}
 
 	fRoot := bytesutil.ToBytes32(cp.Root)
 	if err := s.stateGen.MigrateToCold(ctx, fRoot); err != nil {
@@ -254,7 +257,7 @@ func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) err
 //    else:
 //        # root is older than queried slot, thus a skip slot. Return most recent root prior to slot
 //        return root
-func (s *Service) ancestor(ctx context.Context, root []byte, slot uint64) ([]byte, error) {
+func (s *Service) ancestor(ctx context.Context, root []byte, slot types.Slot) ([]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ancestor")
 	defer span.End()
 
@@ -275,7 +278,7 @@ func (s *Service) ancestor(ctx context.Context, root []byte, slot uint64) ([]byt
 }
 
 // This retrieves an ancestor root using fork choice store. The look up is looping through the a flat array structure.
-func (s *Service) ancestorByForkChoiceStore(ctx context.Context, r [32]byte, slot uint64) ([]byte, error) {
+func (s *Service) ancestorByForkChoiceStore(ctx context.Context, r [32]byte, slot types.Slot) ([]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ancestorByForkChoiceStore")
 	defer span.End()
 
@@ -286,7 +289,7 @@ func (s *Service) ancestorByForkChoiceStore(ctx context.Context, r [32]byte, slo
 }
 
 // This retrieves an ancestor root using DB. The look up is recursively looking up DB. Slower than `ancestorByForkChoiceStore`.
-func (s *Service) ancestorByDB(ctx context.Context, r [32]byte, slot uint64) ([]byte, error) {
+func (s *Service) ancestorByDB(ctx context.Context, r [32]byte, slot types.Slot) ([]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ancestorByDB")
 	defer span.End()
 
@@ -404,6 +407,28 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk *ethpb.
 	return nil
 }
 
+// inserts finalized deposits into our finalized deposit trie.
+func (s *Service) insertFinalizedDeposits(ctx context.Context, fRoot [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.insertFinalizedDeposits")
+	defer span.End()
+
+	// Update deposit cache.
+	finalizedState, err := s.stateGen.StateByRoot(ctx, fRoot)
+	if err != nil {
+		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 := int64(finalizedState.Eth1Data().DepositCount - 1)
+	s.depositCache.InsertFinalizedDeposits(ctx, eth1DepositIndex)
+	// Deposit proofs are only used during state transition and can be safely removed to save space.
+	if err = s.depositCache.PruneProofs(ctx, eth1DepositIndex); err != nil {
+		return errors.Wrap(err, "could not prune deposit proofs")
+	}
+	return nil
+}
+
 // The deletes input attestations from the attestation pool, so proposers don't include them in a block for the future.
 func (s *Service) deletePoolAtts(atts []*ethpb.Attestation) error {
 	for _, att := range atts {

beacon-chain/blockchain/process_block_test.go

@@ -3,10 +3,13 @@ package blockchain
 import (
 	"context"
 	"fmt"
+	"math/big"
+	"strconv"
 	"testing"
 	"time"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
@@ -35,7 +38,7 @@ func TestStore_OnBlock(t *testing.T) {
 		StateGen:        stategen.New(beaconDB),
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
 	}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -77,7 +80,7 @@ func TestStore_OnBlock(t *testing.T) {
 			blk: func() *ethpb.SignedBeaconBlock {
 				b := testutil.NewBeaconBlock()
 				b.Block.ParentRoot = randomParentRoot2
-				b.Block.Slot = params.BeaconConfig().FarFutureEpoch
+				b.Block.Slot = params.BeaconConfig().FarFutureSlot
 				return b
 			}(),
 			s:             st.Copy(),
@@ -130,7 +133,7 @@ func TestStore_OnBlockBatch(t *testing.T) {
 		BeaconDB: beaconDB,
 		StateGen: stategen.New(beaconDB),
 	}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	genesisStateRoot := [32]byte{}
@@ -152,7 +155,7 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	var blkRoots [][32]byte
 	var firstState *stateTrie.BeaconState
 	for i := 1; i < 10; i++ {
-		b, err := testutil.GenerateFullBlock(bState, keys, testutil.DefaultBlockGenConfig(), uint64(i))
+		b, err := testutil.GenerateFullBlock(bState, keys, testutil.DefaultBlockGenConfig(), types.Slot(i))
 		require.NoError(t, err)
 		bState, err = state.ExecuteStateTransition(ctx, bState, b)
 		require.NoError(t, err)
@@ -180,7 +183,7 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	defer params.UseMainnetConfig()
 
 	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	service.genesisTime = time.Now()
 
@@ -199,7 +202,7 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, newJustifiedBlk))
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, lastJustifiedBlk))
 
-	diff := (params.BeaconConfig().SlotsPerEpoch - 1) * params.BeaconConfig().SecondsPerSlot
+	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
 	service.justifiedCheckpt = &ethpb.Checkpoint{Root: lastJustifiedRoot[:]}
 	update, err = service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: newJustifiedRoot[:]})
@@ -214,7 +217,7 @@ func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 	defer params.UseMainnetConfig()
 
 	cfg := &Config{BeaconDB: beaconDB}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	lastJustifiedBlk := testutil.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
@@ -227,7 +230,7 @@ func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, newJustifiedBlk))
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, lastJustifiedBlk))
 
-	diff := (params.BeaconConfig().SlotsPerEpoch - 1) * params.BeaconConfig().SecondsPerSlot
+	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
 	service.justifiedCheckpt = &ethpb.Checkpoint{Root: lastJustifiedRoot[:]}
 
@@ -244,7 +247,7 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 		BeaconDB: beaconDB,
 		StateGen: stategen.New(beaconDB),
 	}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	s, err := stateTrie.InitializeFromProto(&pb.BeaconState{Slot: 1, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
@@ -277,7 +280,7 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 		BeaconDB: beaconDB,
 		StateGen: stategen.New(beaconDB),
 	}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	genesisStateRoot := [32]byte{}
@@ -311,7 +314,7 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	signedBlock := testutil.NewBeaconBlock()
@@ -336,7 +339,7 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	service.bestJustifiedCheckpt.Epoch = 2
 	require.NoError(t, service.updateJustified(context.Background(), s))
 
-	assert.Equal(t, uint64(2), service.bestJustifiedCheckpt.Epoch, "Incorrect justified epoch in service")
+	assert.Equal(t, types.Epoch(2), service.bestJustifiedCheckpt.Epoch, "Incorrect justified epoch in service")
 }
 
 func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
@@ -344,7 +347,7 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}
@@ -382,7 +385,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}
@@ -423,7 +426,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	// Set finalized epoch to 1.
@@ -561,11 +564,11 @@ func TestCurrentSlot_HandlesOverflow(t *testing.T) {
 	svc := Service{genesisTime: timeutils.Now().Add(1 * time.Hour)}
 
 	slot := svc.CurrentSlot()
-	require.Equal(t, uint64(0), slot, "Unexpected slot")
+	require.Equal(t, types.Slot(0), slot, "Unexpected slot")
 }
 func TestAncestorByDB_CtxErr(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
-	service, err := New(ctx, &Config{})
+	service, err := NewService(ctx, &Config{})
 	require.NoError(t, err)
 
 	cancel()
@@ -578,7 +581,7 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	b1 := testutil.NewBeaconBlock()
@@ -621,7 +624,7 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 func TestAncestor_CanUseForkchoice(t *testing.T) {
 	ctx := context.Background()
 	cfg := &Config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	b1 := testutil.NewBeaconBlock()
@@ -660,7 +663,7 @@ func TestAncestor_CanUseDB(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	b1 := testutil.NewBeaconBlock()
@@ -697,7 +700,7 @@ func TestAncestor_CanUseDB(t *testing.T) {
 func TestEnsureRootNotZeroHashes(t *testing.T) {
 	ctx := context.Background()
 	cfg := &Config{}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	service.genesisRoot = [32]byte{'a'}
 
@@ -751,7 +754,7 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
 		beaconState, err := testutil.NewBeaconState()
 		require.NoError(t, err)
 		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(test.args.stateCheckPoint))
-		service, err := New(ctx, &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
+		service, err := NewService(ctx, &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
 		require.NoError(t, err)
 		service.justifiedCheckpt = test.args.cachedCheckPoint
 		require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo(test.want.Root, 32)}))
@@ -843,7 +846,7 @@ func TestVerifyBlkDescendant(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		service, err := New(ctx, &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
+		service, err := NewService(ctx, &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
 		require.NoError(t, err)
 		service.finalizedCheckpt = &ethpb.Checkpoint{
 			Root: tt.args.finalizedRoot[:],
@@ -861,7 +864,7 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 	cfg := &Config{BeaconDB: beaconDB}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	gBlk := testutil.NewBeaconBlock()
@@ -879,17 +882,17 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 
 	require.NoError(t, service.updateJustifiedInitSync(ctx, newCp))
 
-	assert.DeepEqual(t, currentCp, service.prevJustifiedCheckpt, "Incorrect previous justified checkpoint")
-	assert.DeepEqual(t, newCp, service.CurrentJustifiedCheckpt(), "Incorrect current justified checkpoint in cache")
+	assert.DeepSSZEqual(t, currentCp, service.prevJustifiedCheckpt, "Incorrect previous justified checkpoint")
+	assert.DeepSSZEqual(t, newCp, service.CurrentJustifiedCheckpt(), "Incorrect current justified checkpoint in cache")
 	cp, err := service.beaconDB.JustifiedCheckpoint(ctx)
 	require.NoError(t, err)
-	assert.DeepEqual(t, newCp, cp, "Incorrect current justified checkpoint in db")
+	assert.DeepSSZEqual(t, newCp, cp, "Incorrect current justified checkpoint in db")
 }
 
 func TestHandleEpochBoundary_BadMetrics(t *testing.T) {
 	ctx := context.Background()
 	cfg := &Config{}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	s, err := testutil.NewBeaconState()
@@ -902,7 +905,7 @@ func TestHandleEpochBoundary_BadMetrics(t *testing.T) {
 func TestHandleEpochBoundary_UpdateFirstSlot(t *testing.T) {
 	ctx := context.Background()
 	cfg := &Config{}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	s, _ := testutil.DeterministicGenesisState(t, 1024)
@@ -923,7 +926,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
 		DepositCache:    depositCache,
 	}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	gs, keys := testutil.DeterministicGenesisState(t, 32)
@@ -935,7 +938,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
 
 	testState := gs.Copy()
-	for i := uint64(1); i <= 4*params.BeaconConfig().SlotsPerEpoch; i++ {
+	for i := types.Slot(1); i <= 4*params.BeaconConfig().SlotsPerEpoch; i++ {
 		blk, err := testutil.GenerateFullBlock(testState, keys, testutil.DefaultBlockGenConfig(), i)
 		require.NoError(t, err)
 		r, err := blk.Block.HashTreeRoot()
@@ -944,6 +947,49 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 		testState, err = service.stateGen.StateByRoot(ctx, r)
 		require.NoError(t, err)
 	}
-	require.Equal(t, uint64(3), service.CurrentJustifiedCheckpt().Epoch)
-	require.Equal(t, uint64(2), service.FinalizedCheckpt().Epoch)
+	require.Equal(t, types.Epoch(3), service.CurrentJustifiedCheckpt().Epoch)
+	require.Equal(t, types.Epoch(2), service.FinalizedCheckpt().Epoch)
+}
+
+func TestInsertFinalizedDeposits(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	depositCache, err := depositcache.New()
+	require.NoError(t, err)
+	cfg := &Config{
+		BeaconDB:        beaconDB,
+		StateGen:        stategen.New(beaconDB),
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		DepositCache:    depositCache,
+	}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	gs, _ := testutil.DeterministicGenesisState(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+	gBlk, err := service.beaconDB.GenesisBlock(ctx)
+	require.NoError(t, err)
+	gRoot, err := gBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	service.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+	gs = gs.Copy()
+	assert.NoError(t, gs.SetEth1Data(&ethpb.Eth1Data{DepositCount: 10}))
+	assert.NoError(t, service.stateGen.SaveState(ctx, [32]byte{'m', 'o', 'c', 'k'}, gs))
+	zeroSig := [96]byte{}
+	for i := uint64(0); i < uint64(4*params.BeaconConfig().SlotsPerEpoch); i++ {
+		root := []byte(strconv.Itoa(int(i)))
+		depositCache.InsertDeposit(ctx, &ethpb.Deposit{Data: &ethpb.Deposit_Data{
+			PublicKey:             bytesutil.FromBytes48([48]byte{}),
+			WithdrawalCredentials: params.BeaconConfig().ZeroHash[:],
+			Amount:                0,
+			Signature:             zeroSig[:],
+		}, Proof: [][]byte{root}}, 100+i, int64(i), bytesutil.ToBytes32(root))
+	}
+	assert.NoError(t, service.insertFinalizedDeposits(ctx, [32]byte{'m', 'o', 'c', 'k'}))
+	fDeposits := depositCache.FinalizedDeposits(ctx)
+	assert.Equal(t, 9, int(fDeposits.MerkleTrieIndex), "Finalized deposits not inserted correctly")
+	deps := depositCache.AllDeposits(ctx, big.NewInt(109))
+	for _, d := range deps {
+		assert.DeepEqual(t, [][]byte(nil), d.Proof, "Proofs are not empty")
+	}
 }

beacon-chain/blockchain/receive_attestation.go

@@ -39,11 +39,6 @@ func (s *Service) ReceiveAttestationNoPubsub(ctx context.Context, att *ethpb.Att
 		return errors.Wrap(err, "could not process attestation")
 	}
 
-	if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
-		log.Warnf("Resolving fork due to new attestation: %v", err)
-		return nil
-	}
-
 	return nil
 }
 
@@ -102,7 +97,7 @@ func (s *Service) VerifyFinalizedConsistency(ctx context.Context, root []byte) e
 }
 
 // This routine processes fork choice attestations from the pool to account for validator votes and fork choice.
-func (s *Service) processAttestationsRoutine(subscribedToStateEvents chan struct{}) {
+func (s *Service) processAttestationsRoutine(subscribedToStateEvents chan<- struct{}) {
 	// Wait for state to be initialized.
 	stateChannel := make(chan *feed.Event, 1)
 	stateSub := s.stateNotifier.StateFeed().Subscribe(stateChannel)
@@ -124,7 +119,15 @@ func (s *Service) processAttestationsRoutine(subscribedToStateEvents chan struct
 		case <-s.ctx.Done():
 			return
 		case <-st.C():
+			// Continue when there's no fork choice attestation, there's nothing to process and update head.
+			// This covers the condition when the node is still initial syncing to the head of the chain.
+			if s.attPool.ForkchoiceAttestationCount() == 0 {
+				continue
+			}
 			s.processAttestations(s.ctx)
+			if err := s.updateHead(s.ctx, s.getJustifiedBalances()); err != nil {
+				log.Warnf("Resolving fork due to new attestation: %v", err)
+			}
 		}
 	}
 }

beacon-chain/blockchain/receive_attestation_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 	"time"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
@@ -27,7 +28,7 @@ func TestAttestationCheckPtState_FarFutureSlot(t *testing.T) {
 	chainService := setupBeaconChain(t, beaconDB)
 	chainService.genesisTime = time.Now()
 
-	e := helpers.MaxSlotBuffer/params.BeaconConfig().SlotsPerEpoch + 1
+	e := types.Epoch(helpers.MaxSlotBuffer/uint64(params.BeaconConfig().SlotsPerEpoch) + 1)
 	_, err := chainService.AttestationPreState(context.Background(), &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Epoch: e}}})
 	require.ErrorContains(t, "exceeds max allowed value relative to the local clock", err)
 }
@@ -37,7 +38,7 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	b32 := testutil.NewBeaconBlock()
@@ -65,7 +66,7 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
 	b32 := testutil.NewBeaconBlock()
@@ -99,7 +100,7 @@ func TestProcessAttestations_Ok(t *testing.T) {
 		StateGen:        stategen.New(beaconDB),
 		AttPool:         attestations.NewPool(),
 	}
-	service, err := New(ctx, cfg)
+	service, err := NewService(ctx, cfg)
 	service.genesisTime = timeutils.Now().Add(-1 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
 	require.NoError(t, err)
 	genesisState, pks := testutil.DeterministicGenesisState(t, 64)

beacon-chain/blockchain/receive_block.go

@@ -4,23 +4,24 @@ import (
 	"context"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"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"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
 	"github.com/prysmaticlabs/prysm/shared/traceutil"
-	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
 // This defines how many epochs since finality the run time will begin to save hot state on to the DB.
-var epochsSinceFinalitySaveHotStateDB = 100
+var epochsSinceFinalitySaveHotStateDB = types.Epoch(100)
 
 // BlockReceiver interface defines the methods of chain service receive and processing new blocks.
 type BlockReceiver interface {
 	ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error
-	ReceiveBlockInitialSync(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error
 	ReceiveBlockBatch(ctx context.Context, blocks []*ethpb.SignedBeaconBlock, blkRoots [][32]byte) error
 	HasInitSyncBlock(root [32]byte) bool
 }
@@ -33,6 +34,7 @@ type BlockReceiver interface {
 func (s *Service) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlock")
 	defer span.End()
+	receivedTime := timeutils.Now()
 	blockCopy := stateTrie.CopySignedBeaconBlock(block)
 
 	// Apply state transition on the new block.
@@ -43,21 +45,22 @@ func (s *Service) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlo
 	}
 
 	// Update and save head block after fork choice.
-	if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
-		log.WithError(err).Warn("Could not update head")
+	if !featureconfig.Get().UpdateHeadTimely {
+		if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
+			log.WithError(err).Warn("Could not update head")
+		}
+		// Send notification of the processed block to the state feed.
+		s.stateNotifier.StateFeed().Send(&feed.Event{
+			Type: statefeed.BlockProcessed,
+			Data: &statefeed.BlockProcessedData{
+				Slot:        blockCopy.Block.Slot,
+				BlockRoot:   blockRoot,
+				SignedBlock: blockCopy,
+				Verified:    true,
+			},
+		})
 	}
 
-	// Send notification of the processed block to the state feed.
-	s.stateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			Slot:        blockCopy.Block.Slot,
-			BlockRoot:   blockRoot,
-			SignedBlock: blockCopy,
-			Verified:    true,
-		},
-	})
-
 	// Handle post block operations such as attestations and exits.
 	if err := s.handlePostBlockOperations(blockCopy.Block); err != nil {
 		return err
@@ -72,48 +75,11 @@ func (s *Service) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlo
 	reportSlotMetrics(blockCopy.Block.Slot, s.HeadSlot(), s.CurrentSlot(), s.finalizedCheckpt)
 
 	// Log block sync status.
-	logBlockSyncStatus(blockCopy.Block, blockRoot, s.finalizedCheckpt)
-
-	// Log state transition data.
-	logStateTransitionData(blockCopy.Block)
-
-	return nil
-}
-
-// ReceiveBlockInitialSync processes the input block for the purpose of initial syncing.
-// This method should only be used on blocks during initial syncing phase.
-func (s *Service) ReceiveBlockInitialSync(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlockNoVerify")
-	defer span.End()
-	blockCopy := stateTrie.CopySignedBeaconBlock(block)
-
-	// Apply state transition on the new block.
-	if err := s.onBlockInitialSyncStateTransition(ctx, blockCopy, blockRoot); err != nil {
-		err := errors.Wrap(err, "could not process block")
-		traceutil.AnnotateError(span, err)
+	if err := logBlockSyncStatus(blockCopy.Block, blockRoot, s.finalizedCheckpt, receivedTime, uint64(s.genesisTime.Unix())); err != nil {
 		return err
 	}
-
-	// Send notification of the processed block to the state feed.
-	s.stateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			Slot:        blockCopy.Block.Slot,
-			BlockRoot:   blockRoot,
-			SignedBlock: blockCopy,
-			Verified:    true,
-		},
-	})
-
-	// Reports on blockCopy and fork choice metrics.
-	reportSlotMetrics(blockCopy.Block.Slot, s.HeadSlot(), s.CurrentSlot(), s.finalizedCheckpt)
-
 	// Log state transition data.
-	log.WithFields(logrus.Fields{
-		"slot":         blockCopy.Block.Slot,
-		"attestations": len(blockCopy.Block.Body.Attestations),
-		"deposits":     len(blockCopy.Block.Body.Deposits),
-	}).Debug("Finished applying state transition")
+	logStateTransitionData(blockCopy.Block)
 
 	return nil
 }
@@ -197,12 +163,12 @@ func (s *Service) handlePostBlockOperations(b *ethpb.BeaconBlock) error {
 func (s *Service) checkSaveHotStateDB(ctx context.Context) error {
 	currentEpoch := helpers.SlotToEpoch(s.CurrentSlot())
 	// Prevent `sinceFinality` going underflow.
-	var sinceFinality uint64
+	var sinceFinality types.Epoch
 	if currentEpoch > s.finalizedCheckpt.Epoch {
 		sinceFinality = currentEpoch - s.finalizedCheckpt.Epoch
 	}
 
-	if sinceFinality >= uint64(epochsSinceFinalitySaveHotStateDB) {
+	if sinceFinality >= epochsSinceFinalitySaveHotStateDB {
 		s.stateGen.EnableSaveHotStateToDB(ctx)
 		return nil
 	}

beacon-chain/blockchain/receive_block_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 	"time"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	blockchainTesting "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
@@ -25,7 +26,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 	ctx := context.Background()
 
 	genesis, keys := testutil.DeterministicGenesisState(t, 64)
-	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot uint64) *ethpb.SignedBeaconBlock {
+	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot types.Slot) *ethpb.SignedBeaconBlock {
 		blk, err := testutil.GenerateFullBlock(genesis, keys, conf, slot)
 		assert.NoError(t, err)
 		return blk
@@ -133,7 +134,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
 				StateGen:      stategen.New(beaconDB),
 			}
-			s, err := New(ctx, cfg)
+			s, err := NewService(ctx, cfg)
 			require.NoError(t, err)
 			require.NoError(t, s.saveGenesisData(ctx, genesis))
 			gBlk, err := s.beaconDB.GenesisBlock(ctx)
@@ -174,7 +175,7 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 		StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
 		StateGen:      stategen.New(beaconDB),
 	}
-	s, err := New(ctx, cfg)
+	s, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	require.NoError(t, s.saveGenesisData(ctx, genesis))
 	gBlk, err := s.beaconDB.GenesisBlock(ctx)
@@ -198,92 +199,11 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	assert.Equal(t, 2, len(s.forkChoiceStore.Nodes()))
 }
 
-func TestService_ReceiveBlockInitialSync(t *testing.T) {
-	ctx := context.Background()
-
-	genesis, keys := testutil.DeterministicGenesisState(t, 64)
-	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot uint64) *ethpb.SignedBeaconBlock {
-		blk, err := testutil.GenerateFullBlock(genesis, keys, conf, slot)
-		assert.NoError(t, err)
-		return blk
-	}
-
-	type args struct {
-		block *ethpb.SignedBeaconBlock
-	}
-	tests := []struct {
-		name      string
-		args      args
-		wantedErr string
-		check     func(*testing.T, *Service)
-	}{
-		{
-			name: "applies block with state transition",
-			args: args{
-				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 2 /*slot*/),
-			},
-			check: func(t *testing.T, s *Service) {
-				assert.Equal(t, uint64(2), s.head.state.Slot(), "Incorrect head state slot")
-				assert.Equal(t, uint64(2), s.head.block.Block.Slot, "Incorrect head block slot")
-			},
-		},
-		{
-			name: "notifies block processed on state feed",
-			args: args{
-				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 1 /*slot*/),
-			},
-			check: func(t *testing.T, s *Service) {
-				if recvd := len(s.stateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
-					t.Errorf("Received %d state notifications, expected at least 1", recvd)
-				}
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			beaconDB := testDB.SetupDB(t)
-			genesisBlockRoot := bytesutil.ToBytes32(nil)
-
-			cfg := &Config{
-				BeaconDB: beaconDB,
-				ForkChoiceStore: protoarray.New(
-					0, // justifiedEpoch
-					0, // finalizedEpoch
-					genesisBlockRoot,
-				),
-				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
-				StateGen:      stategen.New(beaconDB),
-			}
-			s, err := New(ctx, cfg)
-			require.NoError(t, err)
-			err = s.saveGenesisData(ctx, genesis)
-			require.NoError(t, err)
-			gBlk, err := s.beaconDB.GenesisBlock(ctx)
-			require.NoError(t, err)
-
-			gRoot, err := gBlk.Block.HashTreeRoot()
-			require.NoError(t, err)
-			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
-			root, err := tt.args.block.Block.HashTreeRoot()
-			require.NoError(t, err)
-
-			err = s.ReceiveBlockInitialSync(ctx, tt.args.block, root)
-			if tt.wantedErr != "" {
-				assert.ErrorContains(t, tt.wantedErr, err)
-			} else {
-				assert.NoError(t, err)
-				tt.check(t, s)
-			}
-		})
-	}
-}
-
 func TestService_ReceiveBlockBatch(t *testing.T) {
 	ctx := context.Background()
 
 	genesis, keys := testutil.DeterministicGenesisState(t, 64)
-	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot uint64) *ethpb.SignedBeaconBlock {
+	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot types.Slot) *ethpb.SignedBeaconBlock {
 		blk, err := testutil.GenerateFullBlock(genesis, keys, conf, slot)
 		assert.NoError(t, err)
 		return blk
@@ -304,8 +224,8 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 2 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
-				assert.Equal(t, uint64(2), s.head.state.Slot(), "Incorrect head state slot")
-				assert.Equal(t, uint64(2), s.head.block.Block.Slot, "Incorrect head block slot")
+				assert.Equal(t, types.Slot(2), s.head.state.Slot(), "Incorrect head state slot")
+				assert.Equal(t, types.Slot(2), s.head.block.Block.Slot, "Incorrect head block slot")
 			},
 		},
 		{
@@ -336,7 +256,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
 				StateGen:      stategen.New(beaconDB),
 			}
-			s, err := New(ctx, cfg)
+			s, err := NewService(ctx, cfg)
 			require.NoError(t, err)
 			err = s.saveGenesisData(ctx, genesis)
 			require.NoError(t, err)
@@ -362,7 +282,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 }
 
 func TestService_HasInitSyncBlock(t *testing.T) {
-	s, err := New(context.Background(), &Config{StateNotifier: &blockchainTesting.MockStateNotifier{}})
+	s, err := NewService(context.Background(), &Config{StateNotifier: &blockchainTesting.MockStateNotifier{}})
 	require.NoError(t, err)
 	r := [32]byte{'a'}
 	if s.HasInitSyncBlock(r) {
@@ -377,9 +297,9 @@ func TestService_HasInitSyncBlock(t *testing.T) {
 func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := New(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
+	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
 	require.NoError(t, err)
-	st := params.BeaconConfig().SlotsPerEpoch * uint64(epochsSinceFinalitySaveHotStateDB)
+	st := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epochsSinceFinalitySaveHotStateDB))
 	s.genesisTime = time.Now().Add(time.Duration(-1*int64(st)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
 	s.finalizedCheckpt = &ethpb.Checkpoint{}
 
@@ -390,7 +310,7 @@ func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
 func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := New(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
+	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
 	require.NoError(t, err)
 	s.finalizedCheckpt = &ethpb.Checkpoint{}
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
@@ -403,7 +323,7 @@ func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
 func TestCheckSaveHotStateDB_Overflow(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := New(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
+	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
 	require.NoError(t, err)
 	s.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 10000000}
 	s.genesisTime = time.Now()

beacon-chain/blockchain/service.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
@@ -51,8 +52,8 @@ type Service struct {
 	depositCache          *depositcache.DepositCache
 	chainStartFetcher     powchain.ChainStartFetcher
 	attPool               attestations.Pool
-	slashingPool          *slashings.Pool
-	exitPool              *voluntaryexits.Pool
+	slashingPool          slashings.PoolManager
+	exitPool              voluntaryexits.PoolManager
 	genesisTime           time.Time
 	p2p                   p2p.Broadcaster
 	maxRoutines           int
@@ -66,7 +67,7 @@ type Service struct {
 	bestJustifiedCheckpt  *ethpb.Checkpoint
 	finalizedCheckpt      *ethpb.Checkpoint
 	prevFinalizedCheckpt  *ethpb.Checkpoint
-	nextEpochBoundarySlot uint64
+	nextEpochBoundarySlot types.Slot
 	boundaryRoots         [][32]byte
 	checkpointStateCache  *cache.CheckpointStateCache
 	stateGen              *stategen.State
@@ -75,7 +76,7 @@ type Service struct {
 	initSyncBlocksLock    sync.RWMutex
 	justifiedBalances     []uint64
 	justifiedBalancesLock sync.RWMutex
-	wsEpoch               uint64
+	wsEpoch               types.Epoch
 	wsRoot                []byte
 	wsVerified            bool
 }
@@ -87,8 +88,8 @@ type Config struct {
 	BeaconDB          db.HeadAccessDatabase
 	DepositCache      *depositcache.DepositCache
 	AttPool           attestations.Pool
-	ExitPool          *voluntaryexits.Pool
-	SlashingPool      *slashings.Pool
+	ExitPool          voluntaryexits.PoolManager
+	SlashingPool      slashings.PoolManager
 	P2p               p2p.Broadcaster
 	MaxRoutines       int
 	StateNotifier     statefeed.Notifier
@@ -96,12 +97,12 @@ type Config struct {
 	OpsService        *attestations.Service
 	StateGen          *stategen.State
 	WspBlockRoot      []byte
-	WspEpoch          uint64
+	WspEpoch          types.Epoch
 }
 
-// New instantiates a new block service instance that will
+// NewService instantiates a new block service instance that will
 // be registered into a running beacon node.
-func New(ctx context.Context, cfg *Config) (*Service, error) {
+func NewService(ctx context.Context, cfg *Config) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	return &Service{
 		ctx:                  ctx,
@@ -323,7 +324,7 @@ func (s *Service) initializeBeaconChain(
 	if err := helpers.UpdateCommitteeCache(genesisState, 0 /* genesis epoch */); err != nil {
 		return nil, err
 	}
-	if err := helpers.UpdateProposerIndicesInCache(genesisState, 0 /* genesis epoch */); err != nil {
+	if err := helpers.UpdateProposerIndicesInCache(genesisState); err != nil {
 		return nil, err
 	}
 
@@ -458,7 +459,7 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 			return errors.Wrap(err, "could not retrieve head block")
 		}
 		headEpoch := helpers.SlotToEpoch(headBlock.Block.Slot)
-		var epochsSinceFinality uint64
+		var epochsSinceFinality types.Epoch
 		if headEpoch > finalized.Epoch {
 			epochsSinceFinality = headEpoch - finalized.Epoch
 		}

beacon-chain/blockchain/service_test.go

@@ -86,14 +86,14 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		DepositContainers: []*protodb.DepositContainer{},
 	})
 	require.NoError(t, err)
-	web3Service, err = powchain.New(ctx, &powchain.Web3ServiceConfig{
+	web3Service, err = powchain.NewService(ctx, &powchain.Web3ServiceConfig{
 		BeaconDB:        beaconDB,
 		HTTPEndpoints:   []string{endpoint},
 		DepositContract: common.Address{},
 	})
 	require.NoError(t, err, "Unable to set up web3 service")
 
-	opsService, err := attestations.New(ctx, &attestations.Config{Pool: attestations.NewPool()})
+	opsService, err := attestations.NewService(ctx, &attestations.Config{Pool: attestations.NewPool()})
 	require.NoError(t, err)
 
 	depositCache, err := depositcache.New()
@@ -115,7 +115,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	// Safe a state in stategen to purposes of testing a service stop / shutdown.
 	require.NoError(t, cfg.StateGen.SaveState(ctx, bytesutil.ToBytes32(bState.FinalizedCheckpoint().Root), bState))
 
-	chainService, err := New(ctx, cfg)
+	chainService, err := NewService(ctx, cfg)
 	require.NoError(t, err, "Unable to setup chain service")
 	chainService.genesisTime = time.Unix(1, 0) // non-zero time
 

beacon-chain/blockchain/testing/BUILD.bazel

@@ -23,6 +23,7 @@ go_library(
         "//shared/event:go_default_library",
         "//shared/params:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],

beacon-chain/blockchain/testing/mock.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
@@ -47,7 +48,7 @@ type ChainService struct {
 	ValidAttestation            bool
 	ForkChoiceStore             *protoarray.Store
 	VerifyBlkDescendantErr      error
-	Slot                        *uint64 // Pointer because 0 is a useful value, so checking against it can be incorrect.
+	Slot                        *types.Slot // Pointer because 0 is a useful value, so checking against it can be incorrect.
 }
 
 // StateNotifier mocks the same method in the chain service.
@@ -229,7 +230,7 @@ func (s *ChainService) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeac
 }
 
 // HeadSlot mocks HeadSlot method in chain service.
-func (s *ChainService) HeadSlot() uint64 {
+func (s *ChainService) HeadSlot() types.Slot {
 	if s.State == nil {
 		return 0
 	}
@@ -290,15 +291,15 @@ func (s *ChainService) AttestationPreState(_ context.Context, _ *ethpb.Attestati
 }
 
 // HeadValidatorsIndices mocks the same method in the chain service.
-func (s *ChainService) HeadValidatorsIndices(_ context.Context, epoch uint64) ([]uint64, error) {
+func (s *ChainService) HeadValidatorsIndices(_ context.Context, epoch types.Epoch) ([]types.ValidatorIndex, error) {
 	if s.State == nil {
-		return []uint64{}, nil
+		return []types.ValidatorIndex{}, nil
 	}
 	return helpers.ActiveValidatorIndices(s.State, epoch)
 }
 
 // HeadSeed mocks the same method in the chain service.
-func (s *ChainService) HeadSeed(_ context.Context, epoch uint64) ([32]byte, error) {
+func (s *ChainService) HeadSeed(_ context.Context, epoch types.Epoch) ([32]byte, error) {
 	return helpers.Seed(s.State, epoch, params.BeaconConfig().DomainBeaconAttester)
 }
 
@@ -323,11 +324,11 @@ func (s *ChainService) GenesisValidatorRoot() [32]byte {
 }
 
 // CurrentSlot mocks the same method in the chain service.
-func (s *ChainService) CurrentSlot() uint64 {
+func (s *ChainService) CurrentSlot() types.Slot {
 	if s.Slot != nil {
 		return *s.Slot
 	}
-	return uint64(time.Now().Unix()-s.Genesis.Unix()) / params.BeaconConfig().SecondsPerSlot
+	return types.Slot(uint64(time.Now().Unix()-s.Genesis.Unix()) / params.BeaconConfig().SecondsPerSlot)
 }
 
 // Participation mocks the same method in the chain service.

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
@@ -22,8 +23,8 @@ func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 		wsVerified     bool
 		wantErr        bool
 		wsRoot         [32]byte
-		wsEpoch        uint64
-		finalizedEpoch uint64
+		wsEpoch        types.Epoch
+		finalizedEpoch types.Epoch
 		errString      string
 		name           string
 	}{

beacon-chain/cache/BUILD.bazel

@@ -41,6 +41,7 @@ go_library(
         "@com_github_patrickmn_go_cache//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@io_k8s_client_go//tools/cache:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
@@ -71,6 +72,7 @@ go_test(
         "//shared/testutil/require:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
     ],
 )

beacon-chain/cache/cache_test.go

@@ -2,12 +2,8 @@ package cache
 
 import (
 	"testing"
-
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 )
 
 func TestMain(m *testing.M) {
-	resetCfg := featureconfig.InitWithReset(&featureconfig.Flags{EnableEth1DataVoteCache: true})
-	defer resetCfg()
 	m.Run()
 }

beacon-chain/cache/checkpoint_state_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -60,8 +61,8 @@ func TestCheckpointStateCache_MaxSize(t *testing.T) {
 	require.NoError(t, err)
 
 	for i := uint64(0); i < uint64(maxCheckpointStateSize+100); i++ {
-		require.NoError(t, st.SetSlot(i))
-		require.NoError(t, c.AddCheckpointState(&ethpb.Checkpoint{Epoch: i, Root: make([]byte, 32)}, st))
+		require.NoError(t, st.SetSlot(types.Slot(i)))
+		require.NoError(t, c.AddCheckpointState(&ethpb.Checkpoint{Epoch: types.Epoch(i), Root: make([]byte, 32)}, st))
 	}
 
 	assert.Equal(t, maxCheckpointStateSize, len(c.cache.Keys()))

beacon-chain/cache/committee.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/sliceutil"
 	"k8s.io/client-go/tools/cache"
@@ -55,7 +56,7 @@ func NewCommitteesCache() *CommitteeCache {
 
 // Committee fetches the shuffled indices by slot and committee index. Every list of indices
 // represent one committee. Returns true if the list exists with slot and committee index. Otherwise returns false, nil.
-func (c *CommitteeCache) Committee(slot uint64, seed [32]byte, index uint64) ([]uint64, error) {
+func (c *CommitteeCache) Committee(slot types.Slot, seed [32]byte, index types.CommitteeIndex) ([]types.ValidatorIndex, error) {
 	c.lock.RLock()
 	defer c.lock.RUnlock()
 
@@ -77,11 +78,11 @@ func (c *CommitteeCache) Committee(slot uint64, seed [32]byte, index uint64) ([]
 	}
 
 	committeeCountPerSlot := uint64(1)
-	if item.CommitteeCount/params.BeaconConfig().SlotsPerEpoch > 1 {
-		committeeCountPerSlot = item.CommitteeCount / params.BeaconConfig().SlotsPerEpoch
+	if item.CommitteeCount/uint64(params.BeaconConfig().SlotsPerEpoch) > 1 {
+		committeeCountPerSlot = item.CommitteeCount / uint64(params.BeaconConfig().SlotsPerEpoch)
 	}
 
-	indexOffSet := index + (slot%params.BeaconConfig().SlotsPerEpoch)*committeeCountPerSlot
+	indexOffSet := uint64(index) + uint64(slot.ModSlot(params.BeaconConfig().SlotsPerEpoch).Mul(committeeCountPerSlot))
 	start, end := startEndIndices(item, indexOffSet)
 
 	if end > uint64(len(item.ShuffledIndices)) || end < start {
@@ -105,7 +106,7 @@ func (c *CommitteeCache) AddCommitteeShuffledList(committees *Committees) error
 }
 
 // ActiveIndices returns the active indices of a given seed stored in cache.
-func (c *CommitteeCache) ActiveIndices(seed [32]byte) ([]uint64, error) {
+func (c *CommitteeCache) ActiveIndices(seed [32]byte) ([]types.ValidatorIndex, error) {
 	c.lock.RLock()
 	defer c.lock.RUnlock()
 	obj, exists, err := c.CommitteeCache.GetByKey(key(seed))

beacon-chain/cache/committee_disabled.go

@@ -3,6 +3,8 @@
 // This file is used in fuzzer builds to bypass global committee caches.
 package cache
 
+import types "github.com/prysmaticlabs/eth2-types"
+
 // FakeCommitteeCache is a struct with 1 queue for looking up shuffled indices list by seed.
 type FakeCommitteeCache struct {
 }
@@ -14,7 +16,7 @@ func NewCommitteesCache() *FakeCommitteeCache {
 
 // Committee fetches the shuffled indices by slot and committee index. Every list of indices
 // represent one committee. Returns true if the list exists with slot and committee index. Otherwise returns false, nil.
-func (c *FakeCommitteeCache) Committee(slot uint64, seed [32]byte, index uint64) ([]uint64, error) {
+func (c *FakeCommitteeCache) Committee(slot types.Slot, seed [32]byte, index types.CommitteeIndex) ([]types.ValidatorIndex, error) {
 	return nil, nil
 }
 
@@ -25,12 +27,12 @@ func (c *FakeCommitteeCache) AddCommitteeShuffledList(committees *Committees) er
 }
 
 // AddProposerIndicesList updates the committee shuffled list with proposer indices.
-func (c *FakeCommitteeCache) AddProposerIndicesList(seed [32]byte, indices []uint64) error {
+func (c *FakeCommitteeCache) AddProposerIndicesList(seed [32]byte, indices []types.ValidatorIndex) error {
 	return nil
 }
 
 // ActiveIndices returns the active indices of a given seed stored in cache.
-func (c *FakeCommitteeCache) ActiveIndices(seed [32]byte) ([]uint64, error) {
+func (c *FakeCommitteeCache) ActiveIndices(seed [32]byte) ([]types.ValidatorIndex, error) {
 	return nil, nil
 }
 
@@ -40,7 +42,7 @@ func (c *FakeCommitteeCache) ActiveIndicesCount(seed [32]byte) (int, error) {
 }
 
 // ProposerIndices returns the proposer indices of a given seed.
-func (c *FakeCommitteeCache) ProposerIndices(seed [32]byte) ([]uint64, error) {
+func (c *FakeCommitteeCache) ProposerIndices(seed [32]byte) ([]types.ValidatorIndex, error) {
 	return nil, nil
 }
 

beacon-chain/cache/committee_test.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
@@ -16,7 +17,7 @@ func TestCommitteeKeyFn_OK(t *testing.T) {
 	item := &Committees{
 		CommitteeCount:  1,
 		Seed:            [32]byte{'A'},
-		ShuffledIndices: []uint64{1, 2, 3, 4, 5},
+		ShuffledIndices: []types.ValidatorIndex{1, 2, 3, 4, 5},
 	}
 
 	k, err := committeeKeyFn(item)
@@ -33,13 +34,13 @@ func TestCommitteeCache_CommitteesByEpoch(t *testing.T) {
 	cache := NewCommitteesCache()
 
 	item := &Committees{
-		ShuffledIndices: []uint64{1, 2, 3, 4, 5, 6},
+		ShuffledIndices: []types.ValidatorIndex{1, 2, 3, 4, 5, 6},
 		Seed:            [32]byte{'A'},
 		CommitteeCount:  3,
 	}
 
 	slot := params.BeaconConfig().SlotsPerEpoch
-	committeeIndex := uint64(1)
+	committeeIndex := types.CommitteeIndex(1)
 	indices, err := cache.Committee(slot, item.Seed, committeeIndex)
 	require.NoError(t, err)
 	if indices != nil {
@@ -47,18 +48,18 @@ func TestCommitteeCache_CommitteesByEpoch(t *testing.T) {
 	}
 	require.NoError(t, cache.AddCommitteeShuffledList(item))
 
-	wantedIndex := uint64(0)
+	wantedIndex := types.CommitteeIndex(0)
 	indices, err = cache.Committee(slot, item.Seed, wantedIndex)
 	require.NoError(t, err)
 
-	start, end := startEndIndices(item, wantedIndex)
+	start, end := startEndIndices(item, uint64(wantedIndex))
 	assert.DeepEqual(t, item.ShuffledIndices[start:end], indices)
 }
 
 func TestCommitteeCache_ActiveIndices(t *testing.T) {
 	cache := NewCommitteesCache()
 
-	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []uint64{1, 2, 3, 4, 5, 6}}
+	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []types.ValidatorIndex{1, 2, 3, 4, 5, 6}}
 	indices, err := cache.ActiveIndices(item.Seed)
 	require.NoError(t, err)
 	if indices != nil {
@@ -75,7 +76,7 @@ func TestCommitteeCache_ActiveIndices(t *testing.T) {
 func TestCommitteeCache_ActiveCount(t *testing.T) {
 	cache := NewCommitteesCache()
 
-	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []uint64{1, 2, 3, 4, 5, 6}}
+	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []types.ValidatorIndex{1, 2, 3, 4, 5, 6}}
 	count, err := cache.ActiveIndicesCount(item.Seed)
 	require.NoError(t, err)
 	assert.Equal(t, 0, count, "Expected active count not to exist in empty cache")
@@ -119,8 +120,8 @@ func TestCommitteeCacheOutOfRange(t *testing.T) {
 	err := cache.CommitteeCache.Add(&Committees{
 		CommitteeCount:  1,
 		Seed:            seed,
-		ShuffledIndices: []uint64{0},
-		SortedIndices:   []uint64{},
+		ShuffledIndices: []types.ValidatorIndex{0},
+		SortedIndices:   []types.ValidatorIndex{},
 	})
 	require.NoError(t, err)
 

beacon-chain/cache/committees.go

@@ -1,6 +1,10 @@
 package cache
 
-import "errors"
+import (
+	"errors"
+
+	types "github.com/prysmaticlabs/eth2-types"
+)
 
 // ErrNotCommittee will be returned when a cache object is not a pointer to
 // a Committee struct.
@@ -10,6 +14,6 @@ var ErrNotCommittee = errors.New("object is not a committee struct")
 type Committees struct {
 	CommitteeCount  uint64
 	Seed            [32]byte
-	ShuffledIndices []uint64
-	SortedIndices   []uint64
+	ShuffledIndices []types.ValidatorIndex
+	SortedIndices   []types.ValidatorIndex
 }

beacon-chain/cache/common.go

@@ -8,7 +8,7 @@ import (
 var (
 	// maxCacheSize is 4x of the epoch length for additional cache padding.
 	// Requests should be only accessing committees within defined epoch length.
-	maxCacheSize = 4 * params.BeaconConfig().SlotsPerEpoch
+	maxCacheSize = uint64(4 * params.BeaconConfig().SlotsPerEpoch)
 )
 
 // trim the FIFO queue to the maxSize.

beacon-chain/cache/proposer_indices.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	types "github.com/prysmaticlabs/eth2-types"
 	"k8s.io/client-go/tools/cache"
 )
 
@@ -75,7 +76,7 @@ func (c *ProposerIndicesCache) HasProposerIndices(r [32]byte) (bool, error) {
 }
 
 // ProposerIndices returns the proposer indices of a block root seed.
-func (c *ProposerIndicesCache) ProposerIndices(r [32]byte) ([]uint64, error) {
+func (c *ProposerIndicesCache) ProposerIndices(r [32]byte) ([]types.ValidatorIndex, error) {
 	c.lock.RLock()
 	defer c.lock.RUnlock()
 	obj, exists, err := c.ProposerIndicesCache.GetByKey(key(r))

beacon-chain/cache/proposer_indices_disabled.go

@@ -3,6 +3,8 @@
 // This file is used in fuzzer builds to bypass proposer indices caches.
 package cache
 
+import types "github.com/prysmaticlabs/eth2-types"
+
 // FakeProposerIndicesCache is a struct with 1 queue for looking up proposer indices by root.
 type FakeProposerIndicesCache struct {
 }
@@ -19,7 +21,7 @@ func (c *FakeProposerIndicesCache) AddProposerIndices(p *ProposerIndices) error
 }
 
 // ProposerIndices returns the proposer indices of a block root seed.
-func (c *FakeProposerIndicesCache) ProposerIndices(r [32]byte) ([]uint64, error) {
+func (c *FakeProposerIndicesCache) ProposerIndices(r [32]byte) ([]types.ValidatorIndex, error) {
 	return nil, nil
 }
 

beacon-chain/cache/proposer_indices_test.go

@@ -4,6 +4,7 @@ import (
 	"strconv"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
@@ -12,7 +13,7 @@ import (
 func TestProposerKeyFn_OK(t *testing.T) {
 	item := &ProposerIndices{
 		BlockRoot:       [32]byte{'A'},
-		ProposerIndices: []uint64{1, 2, 3, 4, 5},
+		ProposerIndices: []types.ValidatorIndex{1, 2, 3, 4, 5},
 	}
 
 	k, err := proposerIndicesKeyFn(item)
@@ -48,7 +49,7 @@ func TestProposerCache_AddProposerIndicesList(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, true, has)
 
-	item := &ProposerIndices{BlockRoot: [32]byte{'B'}, ProposerIndices: []uint64{1, 2, 3, 4, 5, 6}}
+	item := &ProposerIndices{BlockRoot: [32]byte{'B'}, ProposerIndices: []types.ValidatorIndex{1, 2, 3, 4, 5, 6}}
 	require.NoError(t, cache.AddProposerIndices(item))
 
 	received, err = cache.ProposerIndices(item.BlockRoot)

beacon-chain/cache/proposer_indices_type.go

@@ -1,6 +1,10 @@
 package cache
 
-import "errors"
+import (
+	"errors"
+
+	types "github.com/prysmaticlabs/eth2-types"
+)
 
 // ErrNotProposerIndices will be returned when a cache object is not a pointer to
 // a ProposerIndices struct.
@@ -9,5 +13,5 @@ var ErrNotProposerIndices = errors.New("object is not a proposer indices struct"
 // ProposerIndices defines the cached struct for proposer indices.
 type ProposerIndices struct {
 	BlockRoot       [32]byte
-	ProposerIndices []uint64
+	ProposerIndices []types.ValidatorIndex
 }

beacon-chain/cache/subnet_ids.go

@@ -6,6 +6,7 @@ import (
 
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/patrickmn/go-cache"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/sliceutil"
 )
@@ -25,7 +26,7 @@ var SubnetIDs = newSubnetIDs()
 func newSubnetIDs() *subnetIDs {
 	// Given a node can calculate committee assignments of current epoch and next epoch.
 	// Max size is set to 2 epoch length.
-	cacheSize := int(params.BeaconConfig().MaxCommitteesPerSlot * params.BeaconConfig().SlotsPerEpoch * 2)
+	cacheSize := int(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().MaxCommitteesPerSlot * 2))
 	attesterCache, err := lru.New(cacheSize)
 	if err != nil {
 		panic(err)
@@ -34,14 +35,14 @@ func newSubnetIDs() *subnetIDs {
 	if err != nil {
 		panic(err)
 	}
-	epochDuration := time.Duration(params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot)
+	epochDuration := time.Duration(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
 	subLength := epochDuration * time.Duration(params.BeaconConfig().EpochsPerRandomSubnetSubscription)
 	persistentCache := cache.New(subLength*time.Second, epochDuration*time.Second)
 	return &subnetIDs{attester: attesterCache, aggregator: aggregatorCache, persistentSubnets: persistentCache}
 }
 
 // AddAttesterSubnetID adds the subnet index for subscribing subnet for the attester of a given slot.
-func (s *subnetIDs) AddAttesterSubnetID(slot, subnetID uint64) {
+func (s *subnetIDs) AddAttesterSubnetID(slot types.Slot, subnetID uint64) {
 	s.attesterLock.Lock()
 	defer s.attesterLock.Unlock()
 
@@ -54,7 +55,7 @@ func (s *subnetIDs) AddAttesterSubnetID(slot, subnetID uint64) {
 }
 
 // GetAttesterSubnetIDs gets the subnet IDs for subscribed subnets for attesters of the slot.
-func (s *subnetIDs) GetAttesterSubnetIDs(slot uint64) []uint64 {
+func (s *subnetIDs) GetAttesterSubnetIDs(slot types.Slot) []uint64 {
 	s.attesterLock.RLock()
 	defer s.attesterLock.RUnlock()
 
@@ -69,7 +70,7 @@ func (s *subnetIDs) GetAttesterSubnetIDs(slot uint64) []uint64 {
 }
 
 // AddAggregatorSubnetID adds the subnet ID for subscribing subnet for the aggregator of a given slot.
-func (s *subnetIDs) AddAggregatorSubnetID(slot, subnetID uint64) {
+func (s *subnetIDs) AddAggregatorSubnetID(slot types.Slot, subnetID uint64) {
 	s.aggregatorLock.Lock()
 	defer s.aggregatorLock.Unlock()
 
@@ -82,7 +83,7 @@ func (s *subnetIDs) AddAggregatorSubnetID(slot, subnetID uint64) {
 }
 
 // GetAggregatorSubnetIDs gets the subnet IDs for subscribing subnet for aggregator of the slot.
-func (s *subnetIDs) GetAggregatorSubnetIDs(slot uint64) []uint64 {
+func (s *subnetIDs) GetAggregatorSubnetIDs(slot types.Slot) []uint64 {
 	s.aggregatorLock.RLock()
 	defer s.aggregatorLock.RUnlock()
 
@@ -132,3 +133,22 @@ func (s *subnetIDs) AddPersistentCommittee(pubkey []byte, comIndex []uint64, dur
 
 	s.persistentSubnets.Set(string(pubkey), comIndex, duration)
 }
+
+// EmptyAllCaches empties out all the related caches and flushes any stored
+// entries on them. This should only ever be used for testing, in normal
+// production, handling of the relevant subnets for each role is done
+// separately.
+func (s *subnetIDs) EmptyAllCaches() {
+	// Clear the caches.
+	s.attesterLock.Lock()
+	s.attester.Purge()
+	s.attesterLock.Unlock()
+
+	s.aggregatorLock.Lock()
+	s.aggregator.Purge()
+	s.aggregatorLock.Unlock()
+
+	s.subnetsLock.Lock()
+	s.persistentSubnets.Flush()
+	s.subnetsLock.Unlock()
+}

beacon-chain/cache/subnet_ids_test.go

@@ -3,13 +3,14 @@ package cache
 import (
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestSubnetIDsCache_RoundTrip(t *testing.T) {
 	c := newSubnetIDs()
-	slot := uint64(100)
+	slot := types.Slot(100)
 	committeeIDs := c.GetAggregatorSubnetIDs(slot)
 	assert.Equal(t, 0, len(committeeIDs), "Empty cache returned an object")
 

beacon-chain/core/blocks/BUILD.bazel

@@ -40,6 +40,7 @@ go_library(
         "//shared/trieutil:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
@@ -84,6 +85,7 @@ go_test(
         "//shared/trieutil:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",

beacon-chain/core/blocks/attestation.go

@@ -1,11 +1,11 @@
 package blocks
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -23,8 +23,8 @@ func ProcessAttestations(
 	beaconState *stateTrie.BeaconState,
 	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
-	if b.Block == nil || b.Block.Body == nil {
-		return nil, errors.New("block and block body can't be nil")
+	if err := helpers.VerifyNilBeaconBlock(b); err != nil {
+		return nil, err
 	}
 
 	var err error
@@ -85,8 +85,8 @@ func ProcessAttestationsNoVerifySignature(
 	beaconState *stateTrie.BeaconState,
 	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
-	if b.Block == nil || b.Block.Body == nil {
-		return nil, errors.New("block and block body can't be nil")
+	if err := helpers.VerifyNilBeaconBlock(b); err != nil {
+		return nil, err
 	}
 	body := b.Block.Body
 	var err error
@@ -112,13 +112,8 @@ func ProcessAttestationNoVerifySignature(
 	if err := helpers.ValidateNilAttestation(att); err != nil {
 		return nil, err
 	}
-	currEpoch := helpers.SlotToEpoch(beaconState.Slot())
-	var prevEpoch uint64
-	if currEpoch == 0 {
-		prevEpoch = 0
-	} else {
-		prevEpoch = currEpoch - 1
-	}
+	currEpoch := helpers.CurrentEpoch(beaconState)
+	prevEpoch := helpers.PrevEpoch(beaconState)
 	data := att.Data
 	if data.Target.Epoch != prevEpoch && data.Target.Epoch != currEpoch {
 		return nil, fmt.Errorf(
@@ -156,7 +151,7 @@ func ProcessAttestationNoVerifySignature(
 		return nil, err
 	}
 	c := helpers.SlotCommitteeCount(activeValidatorCount)
-	if att.Data.CommitteeIndex >= c {
+	if uint64(att.Data.CommitteeIndex) >= c {
 		return nil, fmt.Errorf("committee index %d >= committee count %d", att.Data.CommitteeIndex, c)
 	}
 
@@ -175,33 +170,21 @@ func ProcessAttestationNoVerifySignature(
 		ProposerIndex:   proposerIndex,
 	}
 
-	var ffgSourceEpoch uint64
-	var ffgSourceRoot []byte
-	var ffgTargetEpoch uint64
 	if data.Target.Epoch == currEpoch {
-		ffgSourceEpoch = beaconState.CurrentJustifiedCheckpoint().Epoch
-		ffgSourceRoot = beaconState.CurrentJustifiedCheckpoint().Root
-		ffgTargetEpoch = currEpoch
+		if !beaconState.MatchCurrentJustifiedCheckpoint(data.Source) {
+			return nil, errors.New("source check point not equal to current justified checkpoint")
+		}
 		if err := beaconState.AppendCurrentEpochAttestations(pendingAtt); err != nil {
 			return nil, err
 		}
 	} else {
-		ffgSourceEpoch = beaconState.PreviousJustifiedCheckpoint().Epoch
-		ffgSourceRoot = beaconState.PreviousJustifiedCheckpoint().Root
-		ffgTargetEpoch = prevEpoch
+		if !beaconState.MatchPreviousJustifiedCheckpoint(data.Source) {
+			return nil, errors.New("source check point not equal to previous justified checkpoint")
+		}
 		if err := beaconState.AppendPreviousEpochAttestations(pendingAtt); err != nil {
 			return nil, err
 		}
 	}
-	if data.Source.Epoch != ffgSourceEpoch {
-		return nil, fmt.Errorf("expected source epoch %d, received %d", ffgSourceEpoch, data.Source.Epoch)
-	}
-	if !bytes.Equal(data.Source.Root, ffgSourceRoot) {
-		return nil, fmt.Errorf("expected source root %#x, received %#x", ffgSourceRoot, data.Source.Root)
-	}
-	if data.Target.Epoch != ffgTargetEpoch {
-		return nil, fmt.Errorf("expected target epoch %d, received %d", ffgTargetEpoch, data.Target.Epoch)
-	}
 
 	// Verify attesting indices are correct.
 	committee, err := helpers.BeaconCommitteeFromState(beaconState, att.Data.Slot, att.Data.CommitteeIndex)
@@ -219,60 +202,6 @@ func ProcessAttestationNoVerifySignature(
 	return beaconState, nil
 }
 
-// VerifyAttestationsSignatures will verify the signatures of the provided attestations. This method performs
-// a single BLS verification call to verify the signatures of all of the provided attestations. All
-// of the provided attestations must have valid signatures or this method will return an error.
-// This method does not determine which attestation signature is invalid, only that one or more
-// attestation signatures were not valid.
-func VerifyAttestationsSignatures(ctx context.Context, beaconState *stateTrie.BeaconState, b *ethpb.SignedBeaconBlock) error {
-	ctx, span := trace.StartSpan(ctx, "core.VerifyAttestationsSignatures")
-	defer span.End()
-	atts := b.Block.Body.Attestations
-	span.AddAttributes(trace.Int64Attribute("attestations", int64(len(atts))))
-
-	if len(atts) == 0 {
-		return nil
-	}
-
-	fork := beaconState.Fork()
-	gvr := beaconState.GenesisValidatorRoot()
-	dt := params.BeaconConfig().DomainBeaconAttester
-
-	// Split attestations by fork. Note: the signature domain will differ based on the fork.
-	var preForkAtts []*ethpb.Attestation
-	var postForkAtts []*ethpb.Attestation
-	for _, a := range atts {
-		if helpers.SlotToEpoch(a.Data.Slot) < fork.Epoch {
-			preForkAtts = append(preForkAtts, a)
-		} else {
-			postForkAtts = append(postForkAtts, a)
-		}
-	}
-
-	// Check attestations from before the fork.
-	if fork.Epoch > 0 { // Check to prevent underflow.
-		prevDomain, err := helpers.Domain(fork, fork.Epoch-1, dt, gvr)
-		if err != nil {
-			return err
-		}
-		if err := verifyAttestationsSigWithDomain(ctx, beaconState, preForkAtts, prevDomain); err != nil {
-			return err
-		}
-	} else if len(preForkAtts) > 0 {
-		// This is a sanity check that preForkAtts were not ignored when fork.Epoch == 0. This
-		// condition is not possible, but it doesn't hurt to check anyway.
-		return errors.New("some attestations were not verified from previous fork before genesis")
-	}
-
-	// Then check attestations from after the fork.
-	currDomain, err := helpers.Domain(fork, fork.Epoch, dt, gvr)
-	if err != nil {
-		return err
-	}
-
-	return verifyAttestationsSigWithDomain(ctx, beaconState, postForkAtts, currDomain)
-}
-
 // VerifyAttestationSignature converts and attestation into an indexed attestation and verifies
 // the signature in that attestation.
 func VerifyAttestationSignature(ctx context.Context, beaconState *stateTrie.BeaconState, att *ethpb.Attestation) error {
@@ -320,7 +249,7 @@ func VerifyIndexedAttestation(ctx context.Context, beaconState *stateTrie.Beacon
 	indices := indexedAtt.AttestingIndices
 	var pubkeys []bls.PublicKey
 	for i := 0; i < len(indices); i++ {
-		pubkeyAtIdx := beaconState.PubkeyAtIndex(indices[i])
+		pubkeyAtIdx := beaconState.PubkeyAtIndex(types.ValidatorIndex(indices[i]))
 		pk, err := bls.PublicKeyFromBytes(pubkeyAtIdx[:])
 		if err != nil {
 			return errors.Wrap(err, "could not deserialize validator public key")
@@ -329,23 +258,3 @@ func VerifyIndexedAttestation(ctx context.Context, beaconState *stateTrie.Beacon
 	}
 	return attestationutil.VerifyIndexedAttestationSig(ctx, indexedAtt, pubkeys, domain)
 }
-
-// Inner method to verify attestations. This abstraction allows for the domain to be provided as an
-// argument.
-func verifyAttestationsSigWithDomain(ctx context.Context, beaconState *stateTrie.BeaconState, atts []*ethpb.Attestation, domain []byte) error {
-	if len(atts) == 0 {
-		return nil
-	}
-	set, err := createAttestationSignatureSet(ctx, beaconState, atts, domain)
-	if err != nil {
-		return err
-	}
-	verify, err := set.Verify()
-	if err != nil {
-		return errors.Errorf("got error in multiple verification: %v", err)
-	}
-	if !verify {
-		return errors.New("one or more attestation signatures did not verify")
-	}
-	return nil
-}

beacon-chain/core/blocks/attestation_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
@@ -103,22 +104,11 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
 	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
 	require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
 
-	want := fmt.Sprintf(
-		"expected source epoch %d, received %d",
-		helpers.CurrentEpoch(beaconState),
-		attestations[0].Data.Source.Epoch,
-	)
+	want := "source check point not equal to current justified checkpoint"
 	_, err := blocks.ProcessAttestations(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
-
 	b.Block.Body.Attestations[0].Data.Source.Epoch = helpers.CurrentEpoch(beaconState)
 	b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
-
-	want = fmt.Sprintf(
-		"expected source root %#x, received %#x",
-		beaconState.CurrentJustifiedCheckpoint().Root,
-		attestations[0].Data.Source.Root,
-	)
 	_, err = blocks.ProcessAttestations(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 }
@@ -145,30 +135,19 @@ func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
 		},
 	}
 
-	err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().SlotsPerEpoch + params.BeaconConfig().MinAttestationInclusionDelay)
+	err := beaconState.SetSlot(beaconState.Slot() + 2*params.BeaconConfig().SlotsPerEpoch)
 	require.NoError(t, err)
 	pfc := beaconState.PreviousJustifiedCheckpoint()
 	pfc.Root = []byte("hello-world")
 	require.NoError(t, beaconState.SetPreviousJustifiedCheckpoint(pfc))
 	require.NoError(t, beaconState.SetPreviousEpochAttestations([]*pb.PendingAttestation{}))
 
-	want := fmt.Sprintf(
-		"expected source epoch %d, received %d",
-		helpers.PrevEpoch(beaconState),
-		attestations[0].Data.Source.Epoch,
-	)
+	want := "source check point not equal to previous justified checkpoint"
 	_, err = blocks.ProcessAttestations(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
-
 	b.Block.Body.Attestations[0].Data.Source.Epoch = helpers.PrevEpoch(beaconState)
-	b.Block.Body.Attestations[0].Data.Target.Epoch = helpers.CurrentEpoch(beaconState)
+	b.Block.Body.Attestations[0].Data.Target.Epoch = helpers.PrevEpoch(beaconState)
 	b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
-
-	want = fmt.Sprintf(
-		"expected source root %#x, received %#x",
-		beaconState.CurrentJustifiedCheckpoint().Root,
-		attestations[0].Data.Source.Root,
-	)
 	_, err = blocks.ProcessAttestations(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 }
@@ -503,7 +482,7 @@ func TestConvertToIndexed_OK(t *testing.T) {
 }
 
 func TestVerifyIndexedAttestation_OK(t *testing.T) {
-	numOfValidators := 4 * params.BeaconConfig().SlotsPerEpoch
+	numOfValidators := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))
 	validators := make([]*ethpb.Validator, numOfValidators)
 	_, keys, err := testutil.DeterministicDepositsAndKeys(numOfValidators)
 	require.NoError(t, err)
@@ -596,7 +575,7 @@ func TestValidateIndexedAttestation_AboveMaxLength(t *testing.T) {
 		indexedAtt1.AttestingIndices[i] = i
 		indexedAtt1.Data = &ethpb.AttestationData{
 			Target: &ethpb.Checkpoint{
-				Epoch: i,
+				Epoch: types.Epoch(i),
 			},
 		}
 	}
@@ -648,71 +627,9 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 	assert.ErrorContains(t, want, err)
 }
 
-func TestVerifyAttestations_VerifiesMultipleAttestations(t *testing.T) {
-	ctx := context.Background()
-	numOfValidators := 4 * params.BeaconConfig().SlotsPerEpoch
-	validators := make([]*ethpb.Validator, numOfValidators)
-	_, keys, err := testutil.DeterministicDepositsAndKeys(numOfValidators)
-	require.NoError(t, err)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{
-			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-			PublicKey:             keys[i].PublicKey().Marshal(),
-			WithdrawalCredentials: make([]byte, 32),
-		}
-	}
-
-	st, err := testutil.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, st.SetSlot(5))
-	require.NoError(t, st.SetValidators(validators))
-
-	comm1, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 0 /*committeeIndex*/)
-	require.NoError(t, err)
-	att1 := testutil.HydrateAttestation(&ethpb.Attestation{
-		AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
-		Data: &ethpb.AttestationData{
-			Slot: 1,
-		},
-	})
-	domain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
-	require.NoError(t, err)
-	root, err := helpers.ComputeSigningRoot(att1.Data, domain)
-	require.NoError(t, err)
-	var sigs []bls.Signature
-	for i, u := range comm1 {
-		att1.AggregationBits.SetBitAt(uint64(i), true)
-		sigs = append(sigs, keys[u].Sign(root[:]))
-	}
-	att1.Signature = bls.AggregateSignatures(sigs).Marshal()
-
-	comm2, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 1 /*committeeIndex*/)
-	require.NoError(t, err)
-	att2 := testutil.HydrateAttestation(&ethpb.Attestation{
-		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
-		Data: &ethpb.AttestationData{
-			Slot:           1,
-			CommitteeIndex: 1,
-		},
-	})
-	root, err = helpers.ComputeSigningRoot(att2.Data, domain)
-	require.NoError(t, err)
-	sigs = nil
-	for i, u := range comm2 {
-		att2.AggregationBits.SetBitAt(uint64(i), true)
-		sigs = append(sigs, keys[u].Sign(root[:]))
-	}
-	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
-
-	b := testutil.NewBeaconBlock()
-	b.Block.Body.Attestations = []*ethpb.Attestation{att1, att2}
-	require.NoError(t, blocks.VerifyAttestationsSignatures(ctx, st, b))
-}
-
 func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 	// In this test, att1 is from the prior fork and att2 is from the new fork.
-	ctx := context.Background()
-	numOfValidators := 4 * params.BeaconConfig().SlotsPerEpoch
+	numOfValidators := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))
 	validators := make([]*ethpb.Validator, numOfValidators)
 	_, keys, err := testutil.DeterministicDepositsAndKeys(numOfValidators)
 	require.NoError(t, err)
@@ -772,15 +689,11 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 		sigs = append(sigs, keys[u].Sign(root[:]))
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
-
-	b := testutil.NewBeaconBlock()
-	b.Block.Body.Attestations = []*ethpb.Attestation{att1, att2}
-	require.NoError(t, blocks.VerifyAttestationsSignatures(ctx, st, b))
 }
 
 func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing.T) {
 	ctx := context.Background()
-	numOfValidators := 4 * params.BeaconConfig().SlotsPerEpoch
+	numOfValidators := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))
 	validators := make([]*ethpb.Validator, numOfValidators)
 	_, keys, err := testutil.DeterministicDepositsAndKeys(numOfValidators)
 	require.NoError(t, err)

beacon-chain/core/blocks/attester_slashing.go

@@ -5,6 +5,7 @@ import (
 	"sort"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	v "github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
@@ -38,8 +39,8 @@ func ProcessAttesterSlashings(
 	beaconState *stateTrie.BeaconState,
 	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
-	if b.Block == nil || b.Block.Body == nil {
-		return nil, errors.New("block and block body can't be nil")
+	if err := helpers.VerifyNilBeaconBlock(b); err != nil {
+		return nil, err
 	}
 
 	body := b.Block.Body
@@ -56,12 +57,12 @@ func ProcessAttesterSlashings(
 		var slashedAny bool
 		var val stateTrie.ReadOnlyValidator
 		for _, validatorIndex := range slashableIndices {
-			val, err = beaconState.ValidatorAtIndexReadOnly(validatorIndex)
+			val, err = beaconState.ValidatorAtIndexReadOnly(types.ValidatorIndex(validatorIndex))
 			if err != nil {
 				return nil, err
 			}
 			if helpers.IsSlashableValidator(val.ActivationEpoch(), val.WithdrawableEpoch(), val.Slashed(), currentEpoch) {
-				beaconState, err = v.SlashValidator(beaconState, validatorIndex)
+				beaconState, err = v.SlashValidator(beaconState, types.ValidatorIndex(validatorIndex))
 				if err != nil {
 					return nil, errors.Wrapf(err, "could not slash validator index %d",
 						validatorIndex)

beacon-chain/core/blocks/attester_slashing_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -43,7 +44,7 @@ func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
 		})}}
 
 	var registry []*ethpb.Validator
-	currentSlot := uint64(0)
+	currentSlot := types.Slot(0)
 
 	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
 		Validators: registry,
@@ -62,7 +63,7 @@ func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
 
 func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T) {
 	var registry []*ethpb.Validator
-	currentSlot := uint64(0)
+	currentSlot := types.Slot(0)
 
 	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
 		Validators: registry,
@@ -98,7 +99,7 @@ func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T)
 func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
 	for _, vv := range beaconState.Validators() {
-		vv.WithdrawableEpoch = 1 * params.BeaconConfig().SlotsPerEpoch
+		vv.WithdrawableEpoch = types.Epoch(params.BeaconConfig().SlotsPerEpoch)
 	}
 
 	att1 := testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	fuzz "github.com/google/gofuzz"
+	types "github.com/prysmaticlabs/eth2-types"
 	eth "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -431,7 +432,7 @@ func TestFuzzVerifyExit_10000(t *testing.T) {
 	ve := &eth.SignedVoluntaryExit{}
 	val := stateTrie.ReadOnlyValidator{}
 	fork := &pb.Fork{}
-	var slot uint64
+	var slot types.Slot
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(ve)

beacon-chain/core/blocks/block_regression_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -18,7 +19,7 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 	testutil.ResetCache()
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 5500)
 	for _, vv := range beaconState.Validators() {
-		vv.WithdrawableEpoch = 1 * params.BeaconConfig().SlotsPerEpoch
+		vv.WithdrawableEpoch = types.Epoch(params.BeaconConfig().SlotsPerEpoch)
 	}
 	// This set of indices is very similar to the one from our sapphire testnet
 	// when close to 100 validators were incorrectly slashed. The set is from 0 -5500,

beacon-chain/core/blocks/deposit.go

@@ -70,8 +70,8 @@ func ProcessDeposits(
 	beaconState *stateTrie.BeaconState,
 	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
-	if b.Block == nil || b.Block.Body == nil {
-		return nil, errors.New("block and block body can't be nil")
+	if err := helpers.VerifyNilBeaconBlock(b); err != nil {
+		return nil, err
 	}
 
 	deposits := b.Block.Body.Deposits

beacon-chain/core/blocks/deposit_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -316,11 +317,11 @@ func TestPreGenesisDeposits_SkipInvalidDeposit(t *testing.T) {
 	require.Equal(t, false, ok, "bad pubkey should not exist in state")
 
 	for i := 1; i < newState.NumValidators(); i++ {
-		val, err := newState.ValidatorAtIndex(uint64(i))
+		val, err := newState.ValidatorAtIndex(types.ValidatorIndex(i))
 		require.NoError(t, err)
 		require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, val.EffectiveBalance, "unequal effective balance")
-		require.Equal(t, uint64(0), val.ActivationEpoch)
-		require.Equal(t, uint64(0), val.ActivationEligibilityEpoch)
+		require.Equal(t, types.Epoch(0), val.ActivationEpoch)
+		require.Equal(t, types.Epoch(0), val.ActivationEligibilityEpoch)
 	}
 	if newState.Eth1DepositIndex() != 100 {
 		t.Errorf(

beacon-chain/core/blocks/eth1_data.go

@@ -71,6 +71,6 @@ func Eth1DataHasEnoughSupport(beaconState *stateTrie.BeaconState, data *ethpb.Et
 
 	// If 50+% majority converged on the same eth1data, then it has enough support to update the
 	// state.
-	support := params.BeaconConfig().EpochsPerEth1VotingPeriod * params.BeaconConfig().SlotsPerEpoch
-	return voteCount*2 > support, nil
+	support := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().EpochsPerEth1VotingPeriod))
+	return voteCount*2 > uint64(support), nil
 }

beacon-chain/core/blocks/eth1_data_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -33,10 +34,10 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
 		stateVotes         []*ethpb.Eth1Data
 		data               *ethpb.Eth1Data
 		hasSupport         bool
-		votingPeriodLength uint64
+		votingPeriodLength types.Epoch
 	}{
 		{
-			stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
+			stateVotes: FakeDeposits(uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))),
 			data: &ethpb.Eth1Data{
 				DepositCount: 1,
 				DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
@@ -44,7 +45,7 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
 			hasSupport:         true,
 			votingPeriodLength: 7,
 		}, {
-			stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
+			stateVotes: FakeDeposits(uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))),
 			data: &ethpb.Eth1Data{
 				DepositCount: 1,
 				DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
@@ -52,7 +53,7 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
 			hasSupport:         false,
 			votingPeriodLength: 8,
 		}, {
-			stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
+			stateVotes: FakeDeposits(uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))),
 			data: &ethpb.Eth1Data{
 				DepositCount: 1,
 				DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
@@ -174,7 +175,7 @@ func TestProcessEth1Data_SetsCorrectly(t *testing.T) {
 		},
 	}
 
-	period := params.BeaconConfig().EpochsPerEth1VotingPeriod * params.BeaconConfig().SlotsPerEpoch
+	period := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().EpochsPerEth1VotingPeriod)))
 	for i := uint64(0); i < period; i++ {
 		beaconState, err = blocks.ProcessEth1DataInBlock(context.Background(), beaconState, b)
 		require.NoError(t, err)

beacon-chain/core/blocks/exit.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	v "github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
@@ -48,8 +49,8 @@ func ProcessVoluntaryExits(
 	beaconState *stateTrie.BeaconState,
 	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
-	if b.Block == nil || b.Block.Body == nil {
-		return nil, errors.New("block and block body can't be nil")
+	if err := helpers.VerifyNilBeaconBlock(b); err != nil {
+		return nil, err
 	}
 
 	body := b.Block.Body
@@ -73,39 +74,6 @@ func ProcessVoluntaryExits(
 	return beaconState, nil
 }
 
-// ProcessVoluntaryExitsNoVerifySignature processes all the voluntary exits in
-// a block body, without verifying their BLS signatures.
-// This function is here to satisfy fuzz tests.
-func ProcessVoluntaryExitsNoVerifySignature(
-	beaconState *stateTrie.BeaconState,
-	body *ethpb.BeaconBlockBody,
-) (*stateTrie.BeaconState, error) {
-	exits := body.VoluntaryExits
-
-	for idx, exit := range exits {
-		if exit == nil || exit.Exit == nil {
-			return nil, errors.New("nil exit")
-		}
-		val, err := beaconState.ValidatorAtIndexReadOnly(exit.Exit.ValidatorIndex)
-		if err != nil {
-			return nil, err
-		}
-		if err := verifyExitConditions(val, beaconState.Slot(), exit.Exit); err != nil {
-			return nil, err
-		}
-		// Validate that fork and genesis root are valid.
-		_, err = helpers.Domain(beaconState.Fork(), exit.Exit.Epoch, params.BeaconConfig().DomainVoluntaryExit, beaconState.GenesisValidatorRoot())
-		if err != nil {
-			return nil, err
-		}
-		beaconState, err = v.InitiateValidatorExit(beaconState, exit.Exit.ValidatorIndex)
-		if err != nil {
-			return nil, errors.Wrapf(err, "failed to process voluntary exit at index %d", idx)
-		}
-	}
-	return beaconState, nil
-}
-
 // VerifyExitAndSignature implements the spec defined validation for voluntary exits.
 //
 // Spec pseudocode definition:
@@ -125,7 +93,7 @@ func ProcessVoluntaryExitsNoVerifySignature(
 //    # Verify signature
 //    domain = get_domain(state, DOMAIN_VOLUNTARY_EXIT, exit.epoch)
 //    assert bls_verify(validator.pubkey, signing_root(exit), exit.signature, domain)
-func VerifyExitAndSignature(validator stateTrie.ReadOnlyValidator, currentSlot uint64, fork *pb.Fork, signed *ethpb.SignedVoluntaryExit, genesisRoot []byte) error {
+func VerifyExitAndSignature(validator stateTrie.ReadOnlyValidator, currentSlot types.Slot, fork *pb.Fork, signed *ethpb.SignedVoluntaryExit, genesisRoot []byte) error {
 	if signed == nil || signed.Exit == nil {
 		return errors.New("nil exit")
 	}
@@ -161,7 +129,7 @@ func VerifyExitAndSignature(validator stateTrie.ReadOnlyValidator, currentSlot u
 //    assert get_current_epoch(state) >= exit.epoch
 //    # Verify the validator has been active long enough
 //    assert get_current_epoch(state) >= validator.activation_epoch + SHARD_COMMITTEE_PERIOD
-func verifyExitConditions(validator stateTrie.ReadOnlyValidator, currentSlot uint64, exit *ethpb.VoluntaryExit) error {
+func verifyExitConditions(validator stateTrie.ReadOnlyValidator, currentSlot types.Slot, exit *ethpb.VoluntaryExit) error {
 	currentEpoch := helpers.SlotToEpoch(currentSlot)
 	// Verify the validator is active.
 	if !helpers.IsActiveValidatorUsingTrie(validator, currentEpoch) {

beacon-chain/core/blocks/exit_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -16,73 +17,6 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
-func TestProcessVoluntaryExits_ValidatorNotActive(t *testing.T) {
-	exits := []*ethpb.SignedVoluntaryExit{
-		{
-			Exit: &ethpb.VoluntaryExit{
-				ValidatorIndex: 0,
-			},
-		},
-	}
-	registry := []*ethpb.Validator{
-		{
-			ExitEpoch: 0,
-		},
-	}
-	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Validators: registry,
-	})
-	require.NoError(t, err)
-	b := testutil.NewBeaconBlock()
-	b.Block = &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			VoluntaryExits: exits,
-		},
-	}
-
-	want := "non-active validator cannot exit"
-	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, b)
-	assert.ErrorContains(t, want, err)
-
-	// Check conformance of no verify method.
-	_, err = blocks.ProcessVoluntaryExitsNoVerifySignature(state, b.Block.Body)
-	assert.ErrorContains(t, want, err)
-}
-
-func TestProcessVoluntaryExits_InvalidExitEpoch(t *testing.T) {
-	exits := []*ethpb.SignedVoluntaryExit{
-		{
-			Exit: &ethpb.VoluntaryExit{
-				Epoch: 10,
-			},
-		},
-	}
-	registry := []*ethpb.Validator{
-		{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-		},
-	}
-	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Validators: registry,
-		Slot:       0,
-	})
-	require.NoError(t, err)
-	b := testutil.NewBeaconBlock()
-	b.Block = &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			VoluntaryExits: exits,
-		},
-	}
-
-	want := "expected current epoch >= exit epoch"
-	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, b)
-	assert.ErrorContains(t, want, err)
-
-	// Check conformance of no verify method.
-	_, err = blocks.ProcessVoluntaryExitsNoVerifySignature(state, b.Block.Body)
-	assert.ErrorContains(t, want, err)
-}
-
 func TestProcessVoluntaryExits_NotActiveLongEnoughToExit(t *testing.T) {
 	exits := []*ethpb.SignedVoluntaryExit{
 		{
@@ -168,7 +102,7 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
 		Slot: params.BeaconConfig().SlotsPerEpoch * 5,
 	})
 	require.NoError(t, err)
-	err = state.SetSlot(state.Slot() + (params.BeaconConfig().ShardCommitteePeriod * params.BeaconConfig().SlotsPerEpoch))
+	err = state.SetSlot(state.Slot() + params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)))
 	require.NoError(t, err)
 
 	priv, err := bls.RandKey()
@@ -188,21 +122,11 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
 		},
 	}
 
-	stateCopy := state.Copy()
 	newState, err := blocks.ProcessVoluntaryExits(context.Background(), state, b)
 	require.NoError(t, err, "Could not process exits")
 	newRegistry := newState.Validators()
-	if newRegistry[0].ExitEpoch != helpers.ActivationExitEpoch(state.Slot()/params.BeaconConfig().SlotsPerEpoch) {
+	if newRegistry[0].ExitEpoch != helpers.ActivationExitEpoch(types.Epoch(state.Slot()/params.BeaconConfig().SlotsPerEpoch)) {
 		t.Errorf("Expected validator exit epoch to be %d, got %d",
-			helpers.ActivationExitEpoch(state.Slot()/params.BeaconConfig().SlotsPerEpoch), newRegistry[0].ExitEpoch)
-	}
-
-	// Check conformance with NoVerify Exit Method.
-	newState, err = blocks.ProcessVoluntaryExitsNoVerifySignature(stateCopy, b.Block.Body)
-	require.NoError(t, err, "Could not process exits")
-	newRegistry = newState.Validators()
-	if newRegistry[0].ExitEpoch != helpers.ActivationExitEpoch(stateCopy.Slot()/params.BeaconConfig().SlotsPerEpoch) {
-		t.Errorf("Expected validator exit epoch to be %d, got %d",
-			helpers.ActivationExitEpoch(stateCopy.Slot()/params.BeaconConfig().SlotsPerEpoch), newRegistry[0].ExitEpoch)
+			helpers.ActivationExitEpoch(types.Epoch(state.Slot()/params.BeaconConfig().SlotsPerEpoch)), newRegistry[0].ExitEpoch)
 	}
 }

beacon-chain/core/blocks/proposer_slashing.go

@@ -41,8 +41,8 @@ func ProcessProposerSlashings(
 	beaconState *stateTrie.BeaconState,
 	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
-	if b.Block == nil || b.Block.Body == nil {
-		return nil, errors.New("block and block body can't be nil")
+	if err := helpers.VerifyNilBeaconBlock(b); err != nil {
+		return nil, err
 	}
 
 	body := b.Block.Body

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -21,7 +22,7 @@ import (
 func TestProcessProposerSlashings_UnmatchedHeaderSlots(t *testing.T) {
 	testutil.ResetCache()
 	beaconState, _ := testutil.DeterministicGenesisState(t, 20)
-	currentSlot := uint64(0)
+	currentSlot := types.Slot(0)
 	slashings := []*ethpb.ProposerSlashing{
 		{
 			Header_1: &ethpb.SignedBeaconBlockHeader{
@@ -54,7 +55,7 @@ func TestProcessProposerSlashings_UnmatchedHeaderSlots(t *testing.T) {
 func TestProcessProposerSlashings_SameHeaders(t *testing.T) {
 	testutil.ResetCache()
 	beaconState, _ := testutil.DeterministicGenesisState(t, 2)
-	currentSlot := uint64(0)
+	currentSlot := types.Slot(0)
 	slashings := []*ethpb.ProposerSlashing{
 		{
 			Header_1: &ethpb.SignedBeaconBlockHeader{
@@ -93,7 +94,7 @@ func TestProcessProposerSlashings_ValidatorNotSlashable(t *testing.T) {
 			WithdrawableEpoch: 0,
 		},
 	}
-	currentSlot := uint64(0)
+	currentSlot := types.Slot(0)
 	slashings := []*ethpb.ProposerSlashing{
 		{
 			Header_1: &ethpb.SignedBeaconBlockHeader{
@@ -138,7 +139,7 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 	// We test the case when data is correct and verify the validator
 	// registry has been updated.
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
-	proposerIdx := uint64(1)
+	proposerIdx := types.ValidatorIndex(1)
 
 	header1 := &ethpb.SignedBeaconBlockHeader{
 		Header: testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
@@ -186,7 +187,7 @@ func TestVerifyProposerSlashing(t *testing.T) {
 	}
 
 	beaconState, sks := testutil.DeterministicGenesisState(t, 2)
-	currentSlot := uint64(0)
+	currentSlot := types.Slot(0)
 	require.NoError(t, beaconState.SetSlot(currentSlot))
 	rand1, err := bls.RandKey()
 	require.NoError(t, err)

beacon-chain/core/blocks/randao.go

@@ -30,10 +30,9 @@ func ProcessRandao(
 	beaconState *stateTrie.BeaconState,
 	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
-	if b.Block == nil || b.Block.Body == nil {
-		return nil, errors.New("block and block body can't be nil")
+	if err := helpers.VerifyNilBeaconBlock(b); err != nil {
+		return nil, err
 	}
-
 	body := b.Block.Body
 	buf, proposerPub, domain, err := randaoSigningData(beaconState)
 	if err != nil {
@@ -67,7 +66,7 @@ func ProcessRandaoNoVerify(
 	// If block randao passed verification, we XOR the state's latest randao mix with the block's
 	// randao and update the state's corresponding latest randao mix value.
 	latestMixesLength := params.BeaconConfig().EpochsPerHistoricalVector
-	latestMixSlice, err := beaconState.RandaoMixAtIndex(currentEpoch % latestMixesLength)
+	latestMixSlice, err := beaconState.RandaoMixAtIndex(uint64(currentEpoch % latestMixesLength))
 	if err != nil {
 		return nil, err
 	}
@@ -78,7 +77,7 @@ func ProcessRandaoNoVerify(
 	for i, x := range blockRandaoReveal {
 		latestMixSlice[i] ^= x
 	}
-	if err := beaconState.UpdateRandaoMixesAtIndex(currentEpoch%latestMixesLength, latestMixSlice); err != nil {
+	if err := beaconState.UpdateRandaoMixesAtIndex(uint64(currentEpoch%latestMixesLength), latestMixSlice); err != nil {
 		return nil, err
 	}
 	return beaconState, nil

beacon-chain/core/blocks/randao_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/binary"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -20,9 +21,9 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 	// We fetch the proposer's index as that is whom the RANDAO will be verified against.
 	proposerIdx, err := helpers.BeaconProposerIndex(beaconState)
 	require.NoError(t, err)
-	epoch := uint64(0)
+	epoch := types.Epoch(0)
 	buf := make([]byte, 32)
-	binary.LittleEndian.PutUint64(buf, epoch)
+	binary.LittleEndian.PutUint64(buf, uint64(epoch))
 	domain, err := helpers.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorRoot())
 	require.NoError(t, err)
 	root, err := (&pb.SigningData{ObjectRoot: buf, Domain: domain}).HashTreeRoot()

beacon-chain/core/blocks/signature.go

@@ -5,6 +5,7 @@ import (
 	"encoding/binary"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -114,7 +115,7 @@ func randaoSigningData(beaconState *stateTrie.BeaconState) ([]byte, []byte, []by
 
 	currentEpoch := helpers.SlotToEpoch(beaconState.Slot())
 	buf := make([]byte, 32)
-	binary.LittleEndian.PutUint64(buf, currentEpoch)
+	binary.LittleEndian.PutUint64(buf, uint64(currentEpoch))
 
 	domain, err := helpers.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorRoot())
 	if err != nil {
@@ -148,7 +149,7 @@ func createAttestationSignatureSet(ctx context.Context, beaconState *stateTrie.B
 		indices := ia.AttestingIndices
 		pubkeys := make([][]byte, len(indices))
 		for i := 0; i < len(indices); i++ {
-			pubkeyAtIdx := beaconState.PubkeyAtIndex(indices[i])
+			pubkeyAtIdx := beaconState.PubkeyAtIndex(types.ValidatorIndex(indices[i]))
 			pubkeys[i] = pubkeyAtIdx[:]
 		}
 		aggP, err := bls.AggregatePublicKeys(pubkeys)

beacon-chain/core/epoch/BUILD.bazel

@@ -15,6 +15,7 @@ go_library(
         "//shared/mathutil:go_default_library",
         "//shared/params:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
     ],
 )
@@ -37,6 +38,7 @@ go_test(
         "//shared/testutil/require:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],

beacon-chain/core/epoch/epoch_processing.go

@@ -9,6 +9,7 @@ import (
 	"sort"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
@@ -22,7 +23,7 @@ import (
 // sortableIndices implements the Sort interface to sort newly activated validator indices
 // by activation epoch and by index number.
 type sortableIndices struct {
-	indices    []uint64
+	indices    []types.ValidatorIndex
 	validators []*ethpb.Validator
 }
 
@@ -85,7 +86,7 @@ func ProcessRegistryUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconStat
 		// Process the validators for activation eligibility.
 		if helpers.IsEligibleForActivationQueue(validator) {
 			validator.ActivationEligibilityEpoch = activationEligibilityEpoch
-			if err := state.UpdateValidatorAtIndex(uint64(idx), validator); err != nil {
+			if err := state.UpdateValidatorAtIndex(types.ValidatorIndex(idx), validator); err != nil {
 				return nil, err
 			}
 		}
@@ -94,7 +95,7 @@ func ProcessRegistryUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconStat
 		isActive := helpers.IsActiveValidator(validator, currentEpoch)
 		belowEjectionBalance := validator.EffectiveBalance <= ejectionBal
 		if isActive && belowEjectionBalance {
-			state, err = validators.InitiateValidatorExit(state, uint64(idx))
+			state, err = validators.InitiateValidatorExit(state, types.ValidatorIndex(idx))
 			if err != nil {
 				return nil, errors.Wrapf(err, "could not initiate exit for validator %d", idx)
 			}
@@ -102,10 +103,10 @@ func ProcessRegistryUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconStat
 	}
 
 	// Queue validators eligible for activation and not yet dequeued for activation.
-	var activationQ []uint64
+	var activationQ []types.ValidatorIndex
 	for idx, validator := range vals {
 		if helpers.IsEligibleForActivation(state, validator) {
-			activationQ = append(activationQ, uint64(idx))
+			activationQ = append(activationQ, types.ValidatorIndex(idx))
 		}
 	}
 
@@ -175,17 +176,17 @@ func ProcessSlashings(state *stateTrie.BeaconState) (*stateTrie.BeaconState, err
 	// below equally.
 	increment := params.BeaconConfig().EffectiveBalanceIncrement
 	minSlashing := mathutil.Min(totalSlashing*params.BeaconConfig().ProportionalSlashingMultiplier, totalBalance)
-	err = state.ApplyToEveryValidator(func(idx int, val *ethpb.Validator) (bool, error) {
+	err = state.ApplyToEveryValidator(func(idx int, val *ethpb.Validator) (bool, *ethpb.Validator, error) {
 		correctEpoch := (currentEpoch + exitLength/2) == val.WithdrawableEpoch
 		if val.Slashed && correctEpoch {
 			penaltyNumerator := val.EffectiveBalance / increment * minSlashing
 			penalty := penaltyNumerator / totalBalance * increment
-			if err := helpers.DecreaseBalance(state, uint64(idx), penalty); err != nil {
-				return false, err
+			if err := helpers.DecreaseBalance(state, types.ValidatorIndex(idx), penalty); err != nil {
+				return false, val, err
 			}
-			return true, nil
+			return true, val, nil
 		}
-		return false, nil
+		return false, val, nil
 	})
 	return state, err
 }
@@ -249,23 +250,24 @@ func ProcessFinalUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconState,
 
 	bals := state.Balances()
 	// Update effective balances with hysteresis.
-	validatorFunc := func(idx int, val *ethpb.Validator) (bool, error) {
+	validatorFunc := func(idx int, val *ethpb.Validator) (bool, *ethpb.Validator, error) {
 		if val == nil {
-			return false, fmt.Errorf("validator %d is nil in state", idx)
+			return false, nil, fmt.Errorf("validator %d is nil in state", idx)
 		}
 		if idx >= len(bals) {
-			return false, fmt.Errorf("validator index exceeds validator length in state %d >= %d", idx, len(state.Balances()))
+			return false, nil, fmt.Errorf("validator index exceeds validator length in state %d >= %d", idx, len(state.Balances()))
 		}
 		balance := bals[idx]
 
 		if balance+downwardThreshold < val.EffectiveBalance || val.EffectiveBalance+upwardThreshold < balance {
-			val.EffectiveBalance = maxEffBalance
-			if val.EffectiveBalance > balance-balance%effBalanceInc {
-				val.EffectiveBalance = balance - balance%effBalanceInc
+			newVal := stateTrie.CopyValidator(val)
+			newVal.EffectiveBalance = maxEffBalance
+			if newVal.EffectiveBalance > balance-balance%effBalanceInc {
+				newVal.EffectiveBalance = balance - balance%effBalanceInc
 			}
-			return true, nil
+			return true, newVal, nil
 		}
-		return false, nil
+		return false, val, nil
 	}
 
 	if err := state.ApplyToEveryValidator(validatorFunc); err != nil {
@@ -276,20 +278,20 @@ func ProcessFinalUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconState,
 	slashedExitLength := params.BeaconConfig().EpochsPerSlashingsVector
 	slashedEpoch := nextEpoch % slashedExitLength
 	slashings := state.Slashings()
-	if uint64(len(slashings)) != slashedExitLength {
+	if uint64(len(slashings)) != uint64(slashedExitLength) {
 		return nil, fmt.Errorf(
 			"state slashing length %d different than EpochsPerHistoricalVector %d",
 			len(slashings),
 			slashedExitLength,
 		)
 	}
-	if err := state.UpdateSlashingsAtIndex(slashedEpoch /* index */, 0 /* value */); err != nil {
+	if err := state.UpdateSlashingsAtIndex(uint64(slashedEpoch) /* index */, 0 /* value */); err != nil {
 		return nil, err
 	}
 
 	// Set RANDAO mix.
 	randaoMixLength := params.BeaconConfig().EpochsPerHistoricalVector
-	if uint64(state.RandaoMixesLength()) != randaoMixLength {
+	if uint64(state.RandaoMixesLength()) != uint64(randaoMixLength) {
 		return nil, fmt.Errorf(
 			"state randao length %d different than EpochsPerHistoricalVector %d",
 			state.RandaoMixesLength(),
@@ -300,13 +302,13 @@ func ProcessFinalUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconState,
 	if err != nil {
 		return nil, err
 	}
-	if err := state.UpdateRandaoMixesAtIndex(nextEpoch%randaoMixLength, mix); err != nil {
+	if err := state.UpdateRandaoMixesAtIndex(uint64(nextEpoch%randaoMixLength), mix); err != nil {
 		return nil, err
 	}
 
 	// Set historical root accumulator.
-	epochsPerHistoricalRoot := params.BeaconConfig().SlotsPerHistoricalRoot / params.BeaconConfig().SlotsPerEpoch
-	if nextEpoch%epochsPerHistoricalRoot == 0 {
+	epochsPerHistoricalRoot := params.BeaconConfig().SlotsPerHistoricalRoot.DivSlot(params.BeaconConfig().SlotsPerEpoch)
+	if nextEpoch.Mod(uint64(epochsPerHistoricalRoot)) == 0 {
 		historicalBatch := &pb.HistoricalBatch{
 			BlockRoots: state.BlockRoots(),
 			StateRoots: state.StateRoots(),
@@ -340,8 +342,8 @@ func ProcessFinalUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconState,
 //    for a in attestations:
 //        output = output.union(get_attesting_indices(state, a.data, a.aggregation_bits))
 //    return set(filter(lambda index: not state.validators[index].slashed, output))
-func UnslashedAttestingIndices(state *stateTrie.BeaconState, atts []*pb.PendingAttestation) ([]uint64, error) {
-	var setIndices []uint64
+func UnslashedAttestingIndices(state *stateTrie.BeaconState, atts []*pb.PendingAttestation) ([]types.ValidatorIndex, error) {
+	var setIndices []types.ValidatorIndex
 	seen := make(map[uint64]bool)
 
 	for _, att := range atts {
@@ -356,7 +358,7 @@ func UnslashedAttestingIndices(state *stateTrie.BeaconState, atts []*pb.PendingA
 		// Create a set for attesting indices
 		for _, index := range attestingIndices {
 			if !seen[index] {
-				setIndices = append(setIndices, index)
+				setIndices = append(setIndices, types.ValidatorIndex(index))
 			}
 			seen[index] = true
 		}
@@ -388,7 +390,7 @@ func UnslashedAttestingIndices(state *stateTrie.BeaconState, atts []*pb.PendingA
 //      total_balance = get_total_active_balance(state)
 //	    effective_balance = state.validator_registry[index].effective_balance
 //	    return effective_balance * BASE_REWARD_FACTOR // integer_squareroot(total_balance) // BASE_REWARDS_PER_EPOCH
-func BaseReward(state *stateTrie.BeaconState, index uint64) (uint64, error) {
+func BaseReward(state *stateTrie.BeaconState, index types.ValidatorIndex) (uint64, error) {
 	totalBalance, err := helpers.TotalActiveBalance(state)
 	if err != nil {
 		return 0, errors.Wrap(err, "could not calculate active balance")

beacon-chain/core/epoch/epoch_processing_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch"
@@ -109,7 +110,7 @@ func TestAttestingBalance_CorrectBalance(t *testing.T) {
 			Data: &ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
 				Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
-				Slot:   uint64(i),
+				Slot:   types.Slot(i),
 			},
 			AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 				0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01},
@@ -262,7 +263,7 @@ func TestProcessSlashings_SlashedLess(t *testing.T) {
 }
 
 func TestProcessFinalUpdates_CanProcess(t *testing.T) {
-	s := buildState(t, params.BeaconConfig().SlotsPerHistoricalRoot-1, params.BeaconConfig().SlotsPerEpoch)
+	s := buildState(t, params.BeaconConfig().SlotsPerHistoricalRoot-1, uint64(params.BeaconConfig().SlotsPerEpoch))
 	ce := helpers.CurrentEpoch(s)
 	ne := ce + 1
 	require.NoError(t, s.SetEth1DataVotes([]*ethpb.Eth1Data{}))
@@ -288,7 +289,7 @@ func TestProcessFinalUpdates_CanProcess(t *testing.T) {
 	assert.Equal(t, newS.Slashings()[ce], newS.Slashings()[ne], "Unexpected slashed balance")
 
 	// Verify randao is correctly updated in the right position.
-	mix, err := newS.RandaoMixAtIndex(ne)
+	mix, err := newS.RandaoMixAtIndex(uint64(ne))
 	assert.NoError(t, err)
 	assert.DeepNotEqual(t, params.BeaconConfig().ZeroHash[:], mix, "latest RANDAO still zero hashes")
 
@@ -396,11 +397,11 @@ func TestProcessRegistryUpdates_ValidatorsEjected(t *testing.T) {
 }
 
 func TestProcessRegistryUpdates_CanExits(t *testing.T) {
-	e := uint64(5)
+	e := types.Epoch(5)
 	exitEpoch := helpers.ActivationExitEpoch(e)
 	minWithdrawalDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
 	base := &pb.BeaconState{
-		Slot: e * params.BeaconConfig().SlotsPerEpoch,
+		Slot: params.BeaconConfig().SlotsPerEpoch.Mul(uint64(e)),
 		Validators: []*ethpb.Validator{
 			{
 				ExitEpoch:         exitEpoch,
@@ -420,7 +421,7 @@ func TestProcessRegistryUpdates_CanExits(t *testing.T) {
 	}
 }
 
-func buildState(t testing.TB, slot, validatorCount uint64) *state.BeaconState {
+func buildState(t testing.TB, slot types.Slot, validatorCount uint64) *state.BeaconState {
 	validators := make([]*ethpb.Validator, validatorCount)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{

beacon-chain/core/epoch/precompute/BUILD.bazel

@@ -22,6 +22,7 @@ go_library(
         "//shared/params:go_default_library",
         "//shared/traceutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
@@ -49,6 +50,7 @@ go_test(
         "//shared/testutil/assert:go_default_library",
         "//shared/testutil/require:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],

beacon-chain/core/epoch/precompute/attestation.go

@@ -5,6 +5,7 @@ import (
 	"context"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -106,7 +107,7 @@ func AttestedPrevEpoch(s *stateTrie.BeaconState, a *pb.PendingAttestation) (bool
 }
 
 // SameTarget returns true if attestation `a` attested to the same target block in state.
-func SameTarget(state *stateTrie.BeaconState, a *pb.PendingAttestation, e uint64) (bool, error) {
+func SameTarget(state *stateTrie.BeaconState, a *pb.PendingAttestation, e types.Epoch) (bool, error) {
 	r, err := helpers.BlockRoot(state, e)
 	if err != nil {
 		return false, err
@@ -130,7 +131,7 @@ func SameHead(state *stateTrie.BeaconState, a *pb.PendingAttestation) (bool, err
 }
 
 // UpdateValidator updates pre computed validator store.
-func UpdateValidator(vp []*Validator, record *Validator, indices []uint64, a *pb.PendingAttestation, aSlot uint64) []*Validator {
+func UpdateValidator(vp []*Validator, record *Validator, indices []uint64, a *pb.PendingAttestation, aSlot types.Slot) []*Validator {
 	inclusionSlot := aSlot + a.InclusionDelay
 
 	for _, i := range indices {

beacon-chain/core/epoch/precompute/attestation_test.go

@@ -17,7 +17,7 @@ import (
 )
 
 func TestUpdateValidator_Works(t *testing.T) {
-	e := params.BeaconConfig().FarFutureEpoch
+	e := params.BeaconConfig().FarFutureSlot
 	vp := []*precompute.Validator{{}, {InclusionSlot: e}, {}, {InclusionSlot: e}, {}, {InclusionSlot: e}}
 	record := &precompute.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true,
 		IsPrevEpochAttester: true, IsPrevEpochTargetAttester: true, IsPrevEpochHeadAttester: true}
@@ -34,7 +34,7 @@ func TestUpdateValidator_Works(t *testing.T) {
 }
 
 func TestUpdateValidator_InclusionOnlyCountsPrevEpoch(t *testing.T) {
-	e := params.BeaconConfig().FarFutureEpoch
+	e := params.BeaconConfig().FarFutureSlot
 	vp := []*precompute.Validator{{InclusionSlot: e}}
 	record := &precompute.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true}
 	a := &pb.PendingAttestation{InclusionDelay: 1, ProposerIndex: 2}

beacon-chain/core/epoch/precompute/justification_finalization_test.go

@@ -3,6 +3,7 @@ package precompute_test
 import (
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
@@ -38,16 +39,16 @@ func TestProcessJustificationAndFinalizationPreCompute_ConsecutiveEpochs(t *test
 	}
 	state, err := beaconstate.InitializeFromProto(base)
 	require.NoError(t, err)
-	attestedBalance := 4 * e * 3 / 2
+	attestedBalance := 4 * uint64(e) * 3 / 2
 	b := &precompute.Balance{PrevEpochTargetAttested: attestedBalance}
 	newState, err := precompute.ProcessJustificationAndFinalizationPreCompute(state, b)
 	require.NoError(t, err)
 	rt := [32]byte{byte(64)}
 	assert.DeepEqual(t, rt[:], newState.CurrentJustifiedCheckpoint().Root, "Unexpected justified root")
-	assert.Equal(t, uint64(2), newState.CurrentJustifiedCheckpoint().Epoch, "Unexpected justified epoch")
-	assert.Equal(t, uint64(0), newState.PreviousJustifiedCheckpoint().Epoch, "Unexpected previous justified epoch")
+	assert.Equal(t, types.Epoch(2), newState.CurrentJustifiedCheckpoint().Epoch, "Unexpected justified epoch")
+	assert.Equal(t, types.Epoch(0), newState.PreviousJustifiedCheckpoint().Epoch, "Unexpected previous justified epoch")
 	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], newState.FinalizedCheckpoint().Root, "Unexpected finalized root")
-	assert.Equal(t, uint64(0), newState.FinalizedCheckpointEpoch(), "Unexpected finalized epoch")
+	assert.Equal(t, types.Epoch(0), newState.FinalizedCheckpointEpoch(), "Unexpected finalized epoch")
 }
 
 func TestProcessJustificationAndFinalizationPreCompute_JustifyCurrentEpoch(t *testing.T) {
@@ -75,16 +76,16 @@ func TestProcessJustificationAndFinalizationPreCompute_JustifyCurrentEpoch(t *te
 	}
 	state, err := beaconstate.InitializeFromProto(base)
 	require.NoError(t, err)
-	attestedBalance := 4 * e * 3 / 2
+	attestedBalance := 4 * uint64(e) * 3 / 2
 	b := &precompute.Balance{PrevEpochTargetAttested: attestedBalance}
 	newState, err := precompute.ProcessJustificationAndFinalizationPreCompute(state, b)
 	require.NoError(t, err)
 	rt := [32]byte{byte(64)}
 	assert.DeepEqual(t, rt[:], newState.CurrentJustifiedCheckpoint().Root, "Unexpected current justified root")
-	assert.Equal(t, uint64(2), newState.CurrentJustifiedCheckpoint().Epoch, "Unexpected justified epoch")
-	assert.Equal(t, uint64(0), newState.PreviousJustifiedCheckpoint().Epoch, "Unexpected previous justified epoch")
+	assert.Equal(t, types.Epoch(2), newState.CurrentJustifiedCheckpoint().Epoch, "Unexpected justified epoch")
+	assert.Equal(t, types.Epoch(0), newState.PreviousJustifiedCheckpoint().Epoch, "Unexpected previous justified epoch")
 	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], newState.FinalizedCheckpoint().Root)
-	assert.Equal(t, uint64(0), newState.FinalizedCheckpointEpoch(), "Unexpected finalized epoch")
+	assert.Equal(t, types.Epoch(0), newState.FinalizedCheckpointEpoch(), "Unexpected finalized epoch")
 }
 
 func TestProcessJustificationAndFinalizationPreCompute_JustifyPrevEpoch(t *testing.T) {
@@ -111,14 +112,14 @@ func TestProcessJustificationAndFinalizationPreCompute_JustifyPrevEpoch(t *testi
 	}
 	state, err := beaconstate.InitializeFromProto(base)
 	require.NoError(t, err)
-	attestedBalance := 4 * e * 3 / 2
+	attestedBalance := 4 * uint64(e) * 3 / 2
 	b := &precompute.Balance{PrevEpochTargetAttested: attestedBalance}
 	newState, err := precompute.ProcessJustificationAndFinalizationPreCompute(state, b)
 	require.NoError(t, err)
 	rt := [32]byte{byte(64)}
 	assert.DeepEqual(t, rt[:], newState.CurrentJustifiedCheckpoint().Root, "Unexpected current justified root")
-	assert.Equal(t, uint64(0), newState.PreviousJustifiedCheckpoint().Epoch, "Unexpected previous justified epoch")
-	assert.Equal(t, uint64(2), newState.CurrentJustifiedCheckpoint().Epoch, "Unexpected justified epoch")
+	assert.Equal(t, types.Epoch(0), newState.PreviousJustifiedCheckpoint().Epoch, "Unexpected previous justified epoch")
+	assert.Equal(t, types.Epoch(2), newState.CurrentJustifiedCheckpoint().Epoch, "Unexpected justified epoch")
 	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], newState.FinalizedCheckpoint().Root)
-	assert.Equal(t, uint64(0), newState.FinalizedCheckpointEpoch(), "Unexpected finalized epoch")
+	assert.Equal(t, types.Epoch(0), newState.FinalizedCheckpointEpoch(), "Unexpected finalized epoch")
 }

beacon-chain/core/epoch/precompute/new.go

@@ -45,8 +45,8 @@ func New(ctx context.Context, state *stateTrie.BeaconState) ([]*Validator, *Bala
 		}
 		// Set inclusion slot and inclusion distance to be max, they will be compared and replaced
 		// with the lower values
-		pVal.InclusionSlot = params.BeaconConfig().FarFutureEpoch
-		pVal.InclusionDistance = params.BeaconConfig().FarFutureEpoch
+		pVal.InclusionSlot = params.BeaconConfig().FarFutureSlot
+		pVal.InclusionDistance = params.BeaconConfig().FarFutureSlot
 
 		pValidators[idx] = pVal
 		return nil

beacon-chain/core/epoch/precompute/new_test.go

@@ -29,7 +29,7 @@ func TestNew(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	e := params.BeaconConfig().FarFutureEpoch
+	e := params.BeaconConfig().FarFutureSlot
 	v, b, err := precompute.New(context.Background(), s)
 	require.NoError(t, err)
 	assert.DeepEqual(t, &precompute.Validator{

beacon-chain/core/epoch/precompute/reward_penalty.go

@@ -2,6 +2,7 @@ package precompute
 
 import (
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/mathutil"
@@ -68,7 +69,7 @@ func AttestationsDelta(state *stateTrie.BeaconState, pBal *Balance, vp []*Valida
 	return rewards, penalties, nil
 }
 
-func attestationDelta(pBal *Balance, v *Validator, prevEpoch, finalizedEpoch uint64) (uint64, uint64) {
+func attestationDelta(pBal *Balance, v *Validator, prevEpoch, finalizedEpoch types.Epoch) (uint64, uint64) {
 	eligible := v.IsActivePrevEpoch || (v.IsSlashed && !v.IsWithdrawableCurrentEpoch)
 	if !eligible || pBal.ActiveCurrentEpoch == 0 {
 		return 0, 0
@@ -85,7 +86,7 @@ func attestationDelta(pBal *Balance, v *Validator, prevEpoch, finalizedEpoch uin
 	if v.IsPrevEpochAttester && !v.IsSlashed {
 		proposerReward := br / params.BeaconConfig().ProposerRewardQuotient
 		maxAttesterReward := br - proposerReward
-		r += maxAttesterReward / v.InclusionDistance
+		r += maxAttesterReward / uint64(v.InclusionDistance)
 
 		if isInInactivityLeak(prevEpoch, finalizedEpoch) {
 			// Since full base reward will be canceled out by inactivity penalty deltas,
@@ -139,7 +140,7 @@ func attestationDelta(pBal *Balance, v *Validator, prevEpoch, finalizedEpoch uin
 		// Equivalent to the following condition from the spec:
 		// `index not in get_unslashed_attesting_indices(state, matching_target_attestations)`
 		if !v.IsPrevEpochTargetAttester || v.IsSlashed {
-			p += vb * finalityDelay / params.BeaconConfig().InactivityPenaltyQuotient
+			p += vb * uint64(finalityDelay) / params.BeaconConfig().InactivityPenaltyQuotient
 		}
 	}
 	return r, p
@@ -162,7 +163,7 @@ func ProposersDelta(state *stateTrie.BeaconState, pBal *Balance, vp []*Validator
 	baseRewardsPerEpoch := params.BeaconConfig().BaseRewardsPerEpoch
 	proposerRewardQuotient := params.BeaconConfig().ProposerRewardQuotient
 	for _, v := range vp {
-		if v.ProposerIndex >= uint64(len(rewards)) {
+		if uint64(v.ProposerIndex) >= uint64(len(rewards)) {
 			// This should never happen with a valid state / validator.
 			return nil, errors.New("proposer index out of range")
 		}
@@ -182,7 +183,7 @@ func ProposersDelta(state *stateTrie.BeaconState, pBal *Balance, vp []*Validator
 // Spec code:
 // def is_in_inactivity_leak(state: BeaconState) -> bool:
 //    return get_finality_delay(state) > MIN_EPOCHS_TO_INACTIVITY_PENALTY
-func isInInactivityLeak(prevEpoch, finalizedEpoch uint64) bool {
+func isInInactivityLeak(prevEpoch, finalizedEpoch types.Epoch) bool {
 	return finalityDelay(prevEpoch, finalizedEpoch) > params.BeaconConfig().MinEpochsToInactivityPenalty
 }
 
@@ -191,6 +192,6 @@ func isInInactivityLeak(prevEpoch, finalizedEpoch uint64) bool {
 // Spec code:
 // def get_finality_delay(state: BeaconState) -> uint64:
 //    return get_previous_epoch(state) - state.finalized_checkpoint.epoch
-func finalityDelay(prevEpoch, finalizedEpoch uint64) uint64 {
+func finalityDelay(prevEpoch, finalizedEpoch types.Epoch) types.Epoch {
 	return prevEpoch - finalizedEpoch
 }

beacon-chain/core/epoch/precompute/reward_penalty_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch"
@@ -77,7 +78,7 @@ func TestAttestationDeltaPrecompute(t *testing.T) {
 	base.PreviousEpochAttestations = atts
 	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	slashedAttestedIndices := []uint64{1413}
+	slashedAttestedIndices := []types.ValidatorIndex{1413}
 	for _, i := range slashedAttestedIndices {
 		vs := beaconState.Validators()
 		vs[i].Slashed = true
@@ -100,7 +101,7 @@ func TestAttestationDeltaPrecompute(t *testing.T) {
 	totalBalance, err := helpers.TotalActiveBalance(beaconState)
 	require.NoError(t, err)
 
-	attestedIndices := []uint64{55, 1339, 1746, 1811, 1569}
+	attestedIndices := []types.ValidatorIndex{55, 1339, 1746, 1811, 1569}
 	for _, i := range attestedIndices {
 		base, err := epoch.BaseReward(beaconState, i)
 		require.NoError(t, err, "Could not get base reward")
@@ -112,7 +113,7 @@ func TestAttestationDeltaPrecompute(t *testing.T) {
 		// Base rewards for proposer and attesters working together getting attestation
 		// on chain in the fatest manner
 		proposerReward := base / params.BeaconConfig().ProposerRewardQuotient
-		wanted += (base-proposerReward)*params.BeaconConfig().MinAttestationInclusionDelay - 1
+		wanted += (base-proposerReward)*uint64(params.BeaconConfig().MinAttestationInclusionDelay) - 1
 		assert.Equal(t, wanted, rewards[i], "Unexpected reward balance for validator with index %d", i)
 		// Since all these validators attested, they shouldn't get penalized.
 		assert.Equal(t, uint64(0), penalties[i], "Unexpected penalty balance")
@@ -125,7 +126,7 @@ func TestAttestationDeltaPrecompute(t *testing.T) {
 		assert.Equal(t, 3*base, penalties[i], "Unexpected slashed indices penalty balance")
 	}
 
-	nonAttestedIndices := []uint64{434, 677, 872, 791}
+	nonAttestedIndices := []types.ValidatorIndex{434, 677, 872, 791}
 	for _, i := range nonAttestedIndices {
 		base, err := epoch.BaseReward(beaconState, i)
 		assert.NoError(t, err, "Could not get base reward")
@@ -227,7 +228,7 @@ func TestProcessRewardsAndPenaltiesPrecompute_SlashedInactivePenalty(t *testing.
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch*10))
 
-	slashedAttestedIndices := []uint64{14, 37, 68, 77, 139}
+	slashedAttestedIndices := []types.ValidatorIndex{14, 37, 68, 77, 139}
 	for _, i := range slashedAttestedIndices {
 		vs := beaconState.Validators()
 		vs[i].Slashed = true
@@ -248,13 +249,13 @@ func TestProcessRewardsAndPenaltiesPrecompute_SlashedInactivePenalty(t *testing.
 		penalty := 3 * base
 		proposerReward := base / params.BeaconConfig().ProposerRewardQuotient
 		penalty += params.BeaconConfig().BaseRewardsPerEpoch*base - proposerReward
-		penalty += vp[i].CurrentEpochEffectiveBalance * finalityDelay / params.BeaconConfig().InactivityPenaltyQuotient
+		penalty += vp[i].CurrentEpochEffectiveBalance * uint64(finalityDelay) / params.BeaconConfig().InactivityPenaltyQuotient
 		assert.Equal(t, penalty, penalties[i], "Unexpected slashed indices penalty balance")
 		assert.Equal(t, uint64(0), rewards[i], "Unexpected slashed indices reward balance")
 	}
 }
 
-func buildState(slot, validatorCount uint64) *pb.BeaconState {
+func buildState(slot types.Slot, validatorCount uint64) *pb.BeaconState {
 	validators := make([]*ethpb.Validator, validatorCount)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
@@ -300,7 +301,7 @@ func TestProposerDeltaPrecompute_HappyCase(t *testing.T) {
 	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	proposerIndex := uint64(1)
+	proposerIndex := types.ValidatorIndex(1)
 	b := &Balance{ActiveCurrentEpoch: 1000}
 	v := []*Validator{
 		{IsPrevEpochAttester: true, CurrentEpochEffectiveBalance: 32, ProposerIndex: proposerIndex},
@@ -322,7 +323,7 @@ func TestProposerDeltaPrecompute_ValidatorIndexOutOfRange(t *testing.T) {
 	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	proposerIndex := validatorCount
+	proposerIndex := types.ValidatorIndex(validatorCount)
 	b := &Balance{ActiveCurrentEpoch: 1000}
 	v := []*Validator{
 		{IsPrevEpochAttester: true, CurrentEpochEffectiveBalance: 32, ProposerIndex: proposerIndex},
@@ -338,7 +339,7 @@ func TestProposerDeltaPrecompute_SlashedCase(t *testing.T) {
 	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	proposerIndex := uint64(1)
+	proposerIndex := types.ValidatorIndex(1)
 	b := &Balance{ActiveCurrentEpoch: 1000}
 	v := []*Validator{
 		{IsPrevEpochAttester: true, CurrentEpochEffectiveBalance: 32, ProposerIndex: proposerIndex, IsSlashed: true},
@@ -353,8 +354,8 @@ func TestFinalityDelay(t *testing.T) {
 	base.FinalizedCheckpoint = &ethpb.Checkpoint{Epoch: 3}
 	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	prevEpoch := uint64(0)
-	finalizedEpoch := uint64(0)
+	prevEpoch := types.Epoch(0)
+	finalizedEpoch := types.Epoch(0)
 	// Set values for each test case
 	setVal := func() {
 		prevEpoch = helpers.PrevEpoch(beaconState)
@@ -383,8 +384,8 @@ func TestIsInInactivityLeak(t *testing.T) {
 	base.FinalizedCheckpoint = &ethpb.Checkpoint{Epoch: 3}
 	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	prevEpoch := uint64(0)
-	finalizedEpoch := uint64(0)
+	prevEpoch := types.Epoch(0)
+	finalizedEpoch := types.Epoch(0)
 	// Set values for each test case
 	setVal := func() {
 		prevEpoch = helpers.PrevEpoch(beaconState)

beacon-chain/core/epoch/precompute/slashing.go

@@ -1,6 +1,7 @@
 package precompute
 
 import (
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -42,17 +43,17 @@ func ProcessSlashingsPrecompute(state *stateTrie.BeaconState, pBal *Balance) err
 	}
 
 	increment := params.BeaconConfig().EffectiveBalanceIncrement
-	validatorFunc := func(idx int, val *ethpb.Validator) (bool, error) {
+	validatorFunc := func(idx int, val *ethpb.Validator) (bool, *ethpb.Validator, error) {
 		correctEpoch := epochToWithdraw == val.WithdrawableEpoch
 		if val.Slashed && correctEpoch {
 			penaltyNumerator := val.EffectiveBalance / increment * minSlashing
 			penalty := penaltyNumerator / pBal.ActiveCurrentEpoch * increment
-			if err := helpers.DecreaseBalance(state, uint64(idx), penalty); err != nil {
-				return false, err
+			if err := helpers.DecreaseBalance(state, types.ValidatorIndex(idx), penalty); err != nil {
+				return false, val, err
 			}
-			return true, nil
+			return true, val, nil
 		}
-		return false, nil
+		return false, val, nil
 	}
 
 	return state.ApplyToEveryValidator(validatorFunc)

beacon-chain/core/epoch/precompute/type.go

@@ -1,5 +1,7 @@
 package precompute
 
+import types "github.com/prysmaticlabs/eth2-types"
+
 // Validator stores the pre computation of individual validator's attesting records these records
 // consist of attestation votes, block inclusion record. Pre computing and storing such record
 // is essential for process epoch optimizations.
@@ -26,11 +28,11 @@ type Validator struct {
 	// CurrentEpochEffectiveBalance is how much effective balance this validator validator has current epoch.
 	CurrentEpochEffectiveBalance uint64
 	// InclusionSlot is the slot of when the attestation gets included in the chain.
-	InclusionSlot uint64
+	InclusionSlot types.Slot
 	// InclusionDistance is the distance between the assigned slot and this validator's attestation was included in block.
-	InclusionDistance uint64
+	InclusionDistance types.Slot
 	// ProposerIndex is the index of proposer at slot where this validator's attestation was included.
-	ProposerIndex uint64
+	ProposerIndex types.ValidatorIndex
 	// BeforeEpochTransitionBalance is the validator balance prior to epoch transition.
 	BeforeEpochTransitionBalance uint64
 	// AfterEpochTransitionBalance is the validator balance after epoch transition.

beacon-chain/core/feed/state/BUILD.bazel

@@ -10,6 +10,7 @@ go_library(
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
         "//shared/event:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
     ],
 )

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

@@ -6,6 +6,7 @@ package state
 import (
 	"time"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 )
 
@@ -26,7 +27,7 @@ const (
 // BlockProcessedData is the data sent with BlockProcessed events.
 type BlockProcessedData struct {
 	// Slot is the slot of the processed block.
-	Slot uint64
+	Slot types.Slot
 	// BlockRoot of the processed block.
 	BlockRoot [32]byte
 	// SignedBlock is the physical processed block.
@@ -58,7 +59,7 @@ type InitializedData struct {
 // ReorgData is the data alongside a reorg event.
 type ReorgData struct {
 	// NewSlot is the slot of new state after the reorg.
-	NewSlot uint64
+	NewSlot types.Slot
 	// OldSlot is the slot of the head state before the reorg.
-	OldSlot uint64
+	OldSlot types.Slot
 }

beacon-chain/core/helpers/BUILD.bazel

@@ -43,6 +43,7 @@ go_library(
         "//shared/timeutils:go_default_library",
         "@com_github_ferranbt_fastssz//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],
@@ -78,6 +79,7 @@ go_test(
         "//shared/testutil/require:go_default_library",
         "//shared/timeutils:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],

beacon-chain/core/helpers/attestation.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"time"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/hashutil"
@@ -116,11 +117,11 @@ func ComputeSubnetForAttestation(activeValCount uint64, att *ethpb.Attestation)
 //    slots_since_epoch_start = attestation.data.slot % SLOTS_PER_EPOCH
 //    committees_since_epoch_start = get_committee_count_at_slot(state, attestation.data.slot) * slots_since_epoch_start
 //    return (committees_since_epoch_start + attestation.data.index) % ATTESTATION_SUBNET_COUNT
-func ComputeSubnetFromCommitteeAndSlot(activeValCount, comIdx, attSlot uint64) uint64 {
+func ComputeSubnetFromCommitteeAndSlot(activeValCount uint64, comIdx types.CommitteeIndex, attSlot types.Slot) uint64 {
 	slotSinceStart := SlotsSinceEpochStarts(attSlot)
 	comCount := SlotCommitteeCount(activeValCount)
-	commsSinceStart := comCount * slotSinceStart
-	computedSubnet := (commsSinceStart + comIdx) % params.BeaconNetworkConfig().AttestationSubnetCount
+	commsSinceStart := uint64(slotSinceStart.Mul(comCount))
+	computedSubnet := (commsSinceStart + uint64(comIdx)) % params.BeaconNetworkConfig().AttestationSubnetCount
 	return computedSubnet
 }
 
@@ -135,7 +136,7 @@ func ComputeSubnetFromCommitteeAndSlot(activeValCount, comIdx, attSlot uint64) u
 //   invalid_attestation_slot = 101
 //   valid_attestation_slot = 98
 // In the attestation must be within the range of 95 to 100 in the example above.
-func ValidateAttestationTime(attSlot uint64, genesisTime time.Time) error {
+func ValidateAttestationTime(attSlot types.Slot, genesisTime time.Time) error {
 	if err := ValidateSlotClock(attSlot, uint64(genesisTime.Unix())); err != nil {
 		return err
 	}
@@ -155,7 +156,7 @@ func ValidateAttestationTime(attSlot uint64, genesisTime time.Time) error {
 
 	// An attestation cannot be older than the current slot - attestation propagation slot range
 	// with a minor tolerance for peer clock disparity.
-	lowerBoundsSlot := uint64(0)
+	lowerBoundsSlot := types.Slot(0)
 	if currentSlot > params.BeaconNetworkConfig().AttestationPropagationSlotRange {
 		lowerBoundsSlot = currentSlot - params.BeaconNetworkConfig().AttestationPropagationSlotRange
 	}
@@ -182,10 +183,10 @@ func ValidateAttestationTime(attSlot uint64, genesisTime time.Time) error {
 func VerifyCheckpointEpoch(c *ethpb.Checkpoint, genesis time.Time) bool {
 	now := uint64(timeutils.Now().Unix())
 	genesisTime := uint64(genesis.Unix())
-	currentSlot := (now - genesisTime) / params.BeaconConfig().SecondsPerSlot
+	currentSlot := types.Slot((now - genesisTime) / params.BeaconConfig().SecondsPerSlot)
 	currentEpoch := SlotToEpoch(currentSlot)
 
-	var prevEpoch uint64
+	var prevEpoch types.Epoch
 	if currentEpoch > 1 {
 		prevEpoch = currentEpoch - 1
 	}

beacon-chain/core/helpers/attestation_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 	"time"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -131,7 +132,7 @@ func Test_ValidateAttestationTime(t *testing.T) {
 	}
 
 	type args struct {
-		attSlot     uint64
+		attSlot     types.Slot
 		genesisTime time.Time
 	}
 	tests := []struct {
@@ -219,7 +220,8 @@ func Test_ValidateAttestationTime(t *testing.T) {
 
 func TestVerifyCheckpointEpoch_Ok(t *testing.T) {
 	// Genesis was 6 epochs ago exactly.
-	genesis := time.Now().Add(-1 * time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot*params.BeaconConfig().SlotsPerEpoch*6))
+	offset := params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot * 6)
+	genesis := time.Now().Add(-1 * time.Second * time.Duration(offset))
 	assert.Equal(t, true, helpers.VerifyCheckpointEpoch(&ethpb.Checkpoint{Epoch: 6}, genesis))
 	assert.Equal(t, true, helpers.VerifyCheckpointEpoch(&ethpb.Checkpoint{Epoch: 5}, genesis))
 	assert.Equal(t, false, helpers.VerifyCheckpointEpoch(&ethpb.Checkpoint{Epoch: 4}, genesis))

beacon-chain/core/helpers/block.go

@@ -4,10 +4,28 @@ import (
 	"math"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
+// VerifyNilBeaconBlock checks if any composite field of input signed beacon block is nil.
+// Access to these nil fields will result in run time panic,
+// it is recommended to run these checks as first line of defense.
+func VerifyNilBeaconBlock(b *ethpb.SignedBeaconBlock) error {
+	if b == nil {
+		return errors.New("signed beacon block can't be nil")
+	}
+	if b.Block == nil {
+		return errors.New("beacon block can't be nil")
+	}
+	if b.Block.Body == nil {
+		return errors.New("beacon block body can't be nil")
+	}
+	return nil
+}
+
 // BlockRootAtSlot returns the block root stored in the BeaconState for a recent slot.
 // It returns an error if the requested block root is not within the slot range.
 //
@@ -18,23 +36,23 @@ import (
 //    """
 //    assert slot < state.slot <= slot + SLOTS_PER_HISTORICAL_ROOT
 //    return state.block_roots[slot % SLOTS_PER_HISTORICAL_ROOT]
-func BlockRootAtSlot(state *stateTrie.BeaconState, slot uint64) ([]byte, error) {
+func BlockRootAtSlot(state *stateTrie.BeaconState, slot types.Slot) ([]byte, error) {
 	if math.MaxUint64-slot < params.BeaconConfig().SlotsPerHistoricalRoot {
 		return []byte{}, errors.New("slot overflows uint64")
 	}
 	if slot >= state.Slot() || state.Slot() > slot+params.BeaconConfig().SlotsPerHistoricalRoot {
 		return []byte{}, errors.Errorf("slot %d out of bounds", slot)
 	}
-	return state.BlockRootAtIndex(slot % params.BeaconConfig().SlotsPerHistoricalRoot)
+	return state.BlockRootAtIndex(uint64(slot % params.BeaconConfig().SlotsPerHistoricalRoot))
 }
 
 // StateRootAtSlot returns the cached state root at that particular slot. If no state
 // root has been cached it will return a zero-hash.
-func StateRootAtSlot(state *stateTrie.BeaconState, slot uint64) ([]byte, error) {
+func StateRootAtSlot(state *stateTrie.BeaconState, slot types.Slot) ([]byte, error) {
 	if slot >= state.Slot() || state.Slot() > slot+params.BeaconConfig().SlotsPerHistoricalRoot {
 		return []byte{}, errors.Errorf("slot %d out of bounds", slot)
 	}
-	return state.StateRootAtIndex(slot % params.BeaconConfig().SlotsPerHistoricalRoot)
+	return state.StateRootAtIndex(uint64(slot % params.BeaconConfig().SlotsPerHistoricalRoot))
 }
 
 // BlockRoot returns the block root stored in the BeaconState for epoch start slot.
@@ -45,7 +63,7 @@ func StateRootAtSlot(state *stateTrie.BeaconState, slot uint64) ([]byte, error)
 //    Return the block root at the start of a recent ``epoch``.
 //    """
 //    return get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch))
-func BlockRoot(state *stateTrie.BeaconState, epoch uint64) ([]byte, error) {
+func BlockRoot(state *stateTrie.BeaconState, epoch types.Epoch) ([]byte, error) {
 	s, err := StartSlot(epoch)
 	if err != nil {
 		return nil, err

beacon-chain/core/helpers/block_test.go

@@ -5,6 +5,7 @@ import (
 	"math"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -16,7 +17,7 @@ import (
 func TestBlockRootAtSlot_CorrectBlockRoot(t *testing.T) {
 	var blockRoots [][]byte
 
-	for i := uint64(0); i < params.BeaconConfig().SlotsPerHistoricalRoot; i++ {
+	for i := uint64(0); i < uint64(params.BeaconConfig().SlotsPerHistoricalRoot); i++ {
 		blockRoots = append(blockRoots, []byte{byte(i)})
 	}
 	s := &pb.BeaconState{
@@ -24,8 +25,8 @@ func TestBlockRootAtSlot_CorrectBlockRoot(t *testing.T) {
 	}
 
 	tests := []struct {
-		slot         uint64
-		stateSlot    uint64
+		slot         types.Slot
+		stateSlot    types.Slot
 		expectedRoot [32]byte
 	}{
 		{
@@ -73,7 +74,7 @@ func TestBlockRootAtSlot_CorrectBlockRoot(t *testing.T) {
 func TestBlockRootAtSlot_OutOfBounds(t *testing.T) {
 	var blockRoots [][]byte
 
-	for i := uint64(0); i < params.BeaconConfig().SlotsPerHistoricalRoot; i++ {
+	for i := uint64(0); i < uint64(params.BeaconConfig().SlotsPerHistoricalRoot); i++ {
 		blockRoots = append(blockRoots, []byte{byte(i)})
 	}
 	state := &pb.BeaconState{
@@ -81,8 +82,8 @@ func TestBlockRootAtSlot_OutOfBounds(t *testing.T) {
 	}
 
 	tests := []struct {
-		slot        uint64
-		stateSlot   uint64
+		slot        types.Slot
+		stateSlot   types.Slot
 		expectedErr string
 	}{
 		{

beacon-chain/core/helpers/committee.go

@@ -8,6 +8,7 @@ import (
 	"sort"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
@@ -38,7 +39,7 @@ var proposerIndicesCache = cache.NewProposerIndicesCache()
 //        len(get_active_validator_indices(state, epoch)) // SLOTS_PER_EPOCH // TARGET_COMMITTEE_SIZE,
 //    ))
 func SlotCommitteeCount(activeValidatorCount uint64) uint64 {
-	var committeePerSlot = activeValidatorCount / params.BeaconConfig().SlotsPerEpoch / params.BeaconConfig().TargetCommitteeSize
+	var committeePerSlot = activeValidatorCount / uint64(params.BeaconConfig().SlotsPerEpoch) / params.BeaconConfig().TargetCommitteeSize
 
 	if committeePerSlot > params.BeaconConfig().MaxCommitteesPerSlot {
 		return params.BeaconConfig().MaxCommitteesPerSlot
@@ -67,7 +68,7 @@ func SlotCommitteeCount(activeValidatorCount uint64) uint64 {
 //        index=(slot % SLOTS_PER_EPOCH) * committees_per_slot + index,
 //        count=committees_per_slot * SLOTS_PER_EPOCH,
 //    )
-func BeaconCommitteeFromState(state *stateTrie.BeaconState, slot, committeeIndex uint64) ([]uint64, error) {
+func BeaconCommitteeFromState(state *stateTrie.BeaconState, slot types.Slot, committeeIndex types.CommitteeIndex) ([]types.ValidatorIndex, error) {
 	epoch := SlotToEpoch(slot)
 	seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	if err != nil {
@@ -93,7 +94,7 @@ func BeaconCommitteeFromState(state *stateTrie.BeaconState, slot, committeeIndex
 // BeaconCommittee returns the crosslink committee of a given slot and committee index. The
 // validator indices and seed are provided as an argument rather than a imported implementation
 // from the spec definition. Having them as an argument allows for cheaper computation run time.
-func BeaconCommittee(validatorIndices []uint64, seed [32]byte, slot, committeeIndex uint64) ([]uint64, error) {
+func BeaconCommittee(validatorIndices []types.ValidatorIndex, seed [32]byte, slot types.Slot, committeeIndex types.CommitteeIndex) ([]types.ValidatorIndex, error) {
 	indices, err := committeeCache.Committee(slot, seed, committeeIndex)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not interface with committee cache")
@@ -104,8 +105,8 @@ func BeaconCommittee(validatorIndices []uint64, seed [32]byte, slot, committeeIn
 
 	committeesPerSlot := SlotCommitteeCount(uint64(len(validatorIndices)))
 
-	epochOffset := committeeIndex + (slot%params.BeaconConfig().SlotsPerEpoch)*committeesPerSlot
-	count := committeesPerSlot * params.BeaconConfig().SlotsPerEpoch
+	epochOffset := uint64(committeeIndex) + uint64(slot.ModSlot(params.BeaconConfig().SlotsPerEpoch).Mul(committeesPerSlot))
+	count := committeesPerSlot * uint64(params.BeaconConfig().SlotsPerEpoch)
 
 	return ComputeCommittee(validatorIndices, seed, epochOffset, count)
 }
@@ -125,10 +126,10 @@ func BeaconCommittee(validatorIndices []uint64, seed [32]byte, slot, committeeIn
 //    end = (len(indices) * (index + 1)) // count
 //    return [indices[compute_shuffled_index(ValidatorIndex(i), len(indices), seed)] for i in range(start, end)
 func ComputeCommittee(
-	indices []uint64,
+	indices []types.ValidatorIndex,
 	seed [32]byte,
 	index, count uint64,
-) ([]uint64, error) {
+) ([]types.ValidatorIndex, error) {
 	validatorCount := uint64(len(indices))
 	start := sliceutil.SplitOffset(validatorCount, count, index)
 	end := sliceutil.SplitOffset(validatorCount, count, index+1)
@@ -138,7 +139,7 @@ func ComputeCommittee(
 	}
 
 	// Save the shuffled indices in cache, this is only needed once per epoch or once per new committee index.
-	shuffledIndices := make([]uint64, len(indices))
+	shuffledIndices := make([]types.ValidatorIndex, len(indices))
 	copy(shuffledIndices, indices)
 	// UnshuffleList is used here as it is an optimized implementation created
 	// for fast computation of committees.
@@ -153,9 +154,9 @@ func ComputeCommittee(
 
 // CommitteeAssignmentContainer represents a committee, index, and attester slot for a given epoch.
 type CommitteeAssignmentContainer struct {
-	Committee      []uint64
-	AttesterSlot   uint64
-	CommitteeIndex uint64
+	Committee      []types.ValidatorIndex
+	AttesterSlot   types.Slot
+	CommitteeIndex types.CommitteeIndex
 }
 
 // CommitteeAssignments is a map of validator indices pointing to the appropriate committee
@@ -167,8 +168,8 @@ type CommitteeAssignmentContainer struct {
 // 4. Construct a map of validator indices pointing to the respective committees.
 func CommitteeAssignments(
 	state *stateTrie.BeaconState,
-	epoch uint64,
-) (map[uint64]*CommitteeAssignmentContainer, map[uint64][]uint64, error) {
+	epoch types.Epoch,
+) (map[types.ValidatorIndex]*CommitteeAssignmentContainer, map[types.ValidatorIndex][]types.Slot, error) {
 	nextEpoch := NextEpoch(state)
 	if epoch > nextEpoch {
 		return nil, nil, fmt.Errorf(
@@ -185,7 +186,7 @@ func CommitteeAssignments(
 	if err != nil {
 		return nil, nil, err
 	}
-	proposerIndexToSlots := make(map[uint64][]uint64, params.BeaconConfig().SlotsPerEpoch)
+	proposerIndexToSlots := make(map[types.ValidatorIndex][]types.Slot, params.BeaconConfig().SlotsPerEpoch)
 	// Proposal epochs do not have a look ahead, so we skip them over here.
 	validProposalEpoch := epoch < nextEpoch
 	for slot := startSlot; slot < startSlot+params.BeaconConfig().SlotsPerEpoch && validProposalEpoch; slot++ {
@@ -210,25 +211,25 @@ func CommitteeAssignments(
 	// Each slot in an epoch has a different set of committees. This value is derived from the
 	// active validator set, which does not change.
 	numCommitteesPerSlot := SlotCommitteeCount(uint64(len(activeValidatorIndices)))
-	validatorIndexToCommittee := make(map[uint64]*CommitteeAssignmentContainer, numCommitteesPerSlot*params.BeaconConfig().SlotsPerEpoch)
+	validatorIndexToCommittee := make(map[types.ValidatorIndex]*CommitteeAssignmentContainer, params.BeaconConfig().SlotsPerEpoch.Mul(numCommitteesPerSlot))
 
 	// Compute all committees for all slots.
-	for i := uint64(0); i < params.BeaconConfig().SlotsPerEpoch; i++ {
+	for i := types.Slot(0); i < params.BeaconConfig().SlotsPerEpoch; i++ {
 		// Compute committees.
 		for j := uint64(0); j < numCommitteesPerSlot; j++ {
 			slot := startSlot + i
-			committee, err := BeaconCommitteeFromState(state, slot, j /*committee index*/)
+			committee, err := BeaconCommitteeFromState(state, slot, types.CommitteeIndex(j) /*committee index*/)
 			if err != nil {
 				return nil, nil, err
 			}
 
 			cac := &CommitteeAssignmentContainer{
 				Committee:      committee,
-				CommitteeIndex: j,
+				CommitteeIndex: types.CommitteeIndex(j),
 				AttesterSlot:   slot,
 			}
-			for _, vID := range committee {
-				validatorIndexToCommittee[vID] = cac
+			for _, vIndex := range committee {
+				validatorIndexToCommittee[vIndex] = cac
 			}
 		}
 	}
@@ -267,16 +268,16 @@ func VerifyAttestationBitfieldLengths(state *stateTrie.BeaconState, att *ethpb.A
 
 // ShuffledIndices uses input beacon state and returns the shuffled indices of the input epoch,
 // the shuffled indices then can be used to break up into committees.
-func ShuffledIndices(state *stateTrie.BeaconState, epoch uint64) ([]uint64, error) {
+func ShuffledIndices(state *stateTrie.BeaconState, epoch types.Epoch) ([]types.ValidatorIndex, error) {
 	seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	if err != nil {
 		return nil, errors.Wrapf(err, "could not get seed for epoch %d", epoch)
 	}
 
-	indices := make([]uint64, 0, state.NumValidators())
+	indices := make([]types.ValidatorIndex, 0, state.NumValidators())
 	if err := state.ReadFromEveryValidator(func(idx int, val stateTrie.ReadOnlyValidator) error {
 		if IsActiveValidatorUsingTrie(val, epoch) {
-			indices = append(indices, uint64(idx))
+			indices = append(indices, types.ValidatorIndex(idx))
 		}
 		return nil
 	}); err != nil {
@@ -289,8 +290,8 @@ func ShuffledIndices(state *stateTrie.BeaconState, epoch uint64) ([]uint64, erro
 
 // UpdateCommitteeCache gets called at the beginning of every epoch to cache the committee shuffled indices
 // list with committee index and epoch number. It caches the shuffled indices for current epoch and next epoch.
-func UpdateCommitteeCache(state *stateTrie.BeaconState, epoch uint64) error {
-	for _, e := range []uint64{epoch, epoch + 1} {
+func UpdateCommitteeCache(state *stateTrie.BeaconState, epoch types.Epoch) error {
+	for _, e := range []types.Epoch{epoch, epoch + 1} {
 		seed, err := Seed(state, e, params.BeaconConfig().DomainBeaconAttester)
 		if err != nil {
 			return err
@@ -310,7 +311,7 @@ func UpdateCommitteeCache(state *stateTrie.BeaconState, epoch uint64) error {
 		// Store the sorted indices as well as shuffled indices. In current spec,
 		// sorted indices is required to retrieve proposer index. This is also
 		// used for failing verify signature fallback.
-		sortedIndices := make([]uint64, len(shuffledIndices))
+		sortedIndices := make([]types.ValidatorIndex, len(shuffledIndices))
 		copy(sortedIndices, shuffledIndices)
 		sort.Slice(sortedIndices, func(i, j int) bool {
 			return sortedIndices[i] < sortedIndices[j]
@@ -318,7 +319,7 @@ func UpdateCommitteeCache(state *stateTrie.BeaconState, epoch uint64) error {
 
 		if err := committeeCache.AddCommitteeShuffledList(&cache.Committees{
 			ShuffledIndices: shuffledIndices,
-			CommitteeCount:  count * params.BeaconConfig().SlotsPerEpoch,
+			CommitteeCount:  uint64(params.BeaconConfig().SlotsPerEpoch.Mul(count)),
 			Seed:            seed,
 			SortedIndices:   sortedIndices,
 		}); err != nil {
@@ -330,15 +331,15 @@ func UpdateCommitteeCache(state *stateTrie.BeaconState, epoch uint64) error {
 }
 
 // UpdateProposerIndicesInCache updates proposer indices entry of the committee cache.
-func UpdateProposerIndicesInCache(state *stateTrie.BeaconState, epoch uint64) error {
+func UpdateProposerIndicesInCache(state *stateTrie.BeaconState) error {
 	// The cache uses the state root at the (current epoch - 2)'s slot as key. (e.g. for epoch 2, the key is root at slot 31)
 	// Which is the reason why we skip genesis epoch.
-	if epoch <= params.BeaconConfig().GenesisEpoch+params.BeaconConfig().MinSeedLookahead {
+	if CurrentEpoch(state) <= params.BeaconConfig().GenesisEpoch+params.BeaconConfig().MinSeedLookahead {
 		return nil
 	}
 
 	// Use state root from (current_epoch - 1 - lookahead))
-	wantedEpoch := PrevEpoch(state)
+	wantedEpoch := CurrentEpoch(state) - 1
 	if wantedEpoch >= params.BeaconConfig().MinSeedLookahead {
 		wantedEpoch -= params.BeaconConfig().MinSeedLookahead
 	}
@@ -363,7 +364,7 @@ func UpdateProposerIndicesInCache(state *stateTrie.BeaconState, epoch uint64) er
 		return nil
 	}
 
-	indices, err := ActiveValidatorIndices(state, epoch)
+	indices, err := ActiveValidatorIndices(state, CurrentEpoch(state))
 	if err != nil {
 		return err
 	}
@@ -385,9 +386,9 @@ func ClearCache() {
 
 // This computes proposer indices of the current epoch and returns a list of proposer indices,
 // the index of the list represents the slot number.
-func precomputeProposerIndices(state *stateTrie.BeaconState, activeIndices []uint64) ([]uint64, error) {
+func precomputeProposerIndices(state *stateTrie.BeaconState, activeIndices []types.ValidatorIndex) ([]types.ValidatorIndex, error) {
 	hashFunc := hashutil.CustomSHA256Hasher()
-	proposerIndices := make([]uint64, params.BeaconConfig().SlotsPerEpoch)
+	proposerIndices := make([]types.ValidatorIndex, params.BeaconConfig().SlotsPerEpoch)
 
 	e := CurrentEpoch(state)
 	seed, err := Seed(state, e, params.BeaconConfig().DomainBeaconProposer)
@@ -398,8 +399,8 @@ func precomputeProposerIndices(state *stateTrie.BeaconState, activeIndices []uin
 	if err != nil {
 		return nil, err
 	}
-	for i := uint64(0); i < params.BeaconConfig().SlotsPerEpoch; i++ {
-		seedWithSlot := append(seed[:], bytesutil.Bytes8(slot+i)...)
+	for i := uint64(0); i < uint64(params.BeaconConfig().SlotsPerEpoch); i++ {
+		seedWithSlot := append(seed[:], bytesutil.Bytes8(uint64(slot)+i)...)
 		seedWithSlotHash := hashFunc(seedWithSlot)
 		index, err := ComputeProposerIndex(state, activeIndices, seedWithSlotHash)
 		if err != nil {

beacon-chain/core/helpers/committee_test.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/go-bitfield"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -69,7 +70,7 @@ func TestComputeCommittee_WithoutCache(t *testing.T) {
 }
 
 func TestComputeCommittee_RegressionTest(t *testing.T) {
-	indices := []uint64{1, 3, 8, 16, 18, 19, 20, 23, 30, 35, 43, 46, 47, 54, 56, 58, 69, 70, 71, 83, 84, 85, 91, 96, 100, 103, 105, 106, 112, 121, 127, 128, 129, 140, 142, 144, 146, 147, 149, 152, 153, 154, 157, 160, 173, 175, 180, 182, 188, 189, 191, 194, 201, 204, 217, 221, 226, 228, 230, 231, 239, 241, 249, 250, 255}
+	indices := []types.ValidatorIndex{1, 3, 8, 16, 18, 19, 20, 23, 30, 35, 43, 46, 47, 54, 56, 58, 69, 70, 71, 83, 84, 85, 91, 96, 100, 103, 105, 106, 112, 121, 127, 128, 129, 140, 142, 144, 146, 147, 149, 152, 153, 154, 157, 160, 173, 175, 180, 182, 188, 189, 191, 194, 201, 204, 217, 221, 226, 228, 230, 231, 239, 241, 249, 250, 255}
 	seed := [32]byte{68, 110, 161, 250, 98, 230, 161, 172, 227, 226, 99, 11, 138, 124, 201, 134, 38, 197, 0, 120, 6, 165, 122, 34, 19, 216, 43, 226, 210, 114, 165, 183}
 	index := uint64(215)
 	count := uint64(32)
@@ -89,7 +90,7 @@ func TestVerifyBitfieldLength_OK(t *testing.T) {
 
 func TestCommitteeAssignments_CannotRetrieveFutureEpoch(t *testing.T) {
 	ClearCache()
-	epoch := uint64(1)
+	epoch := types.Epoch(1)
 	state, err := beaconstate.InitializeFromProto(&pb.BeaconState{
 		Slot: 0, // Epoch 0.
 	})
@@ -101,7 +102,7 @@ func TestCommitteeAssignments_CannotRetrieveFutureEpoch(t *testing.T) {
 func TestCommitteeAssignments_NoProposerForSlot0(t *testing.T) {
 	validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch)
 	for i := 0; i < len(validators); i++ {
-		var activationEpoch uint64
+		var activationEpoch types.Epoch
 		if i >= len(validators)/2 {
 			activationEpoch = 3
 		}
@@ -131,7 +132,7 @@ func TestCommitteeAssignments_CanRetrieve(t *testing.T) {
 	validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch)
 	for i := 0; i < len(validators); i++ {
 		// First 2 epochs only half validators are activated.
-		var activationEpoch uint64
+		var activationEpoch types.Epoch
 		if i >= len(validators)/2 {
 			activationEpoch = 3
 		}
@@ -149,24 +150,24 @@ func TestCommitteeAssignments_CanRetrieve(t *testing.T) {
 	require.NoError(t, err)
 
 	tests := []struct {
-		index          uint64
-		slot           uint64
-		committee      []uint64
-		committeeIndex uint64
+		index          types.ValidatorIndex
+		slot           types.Slot
+		committee      []types.ValidatorIndex
+		committeeIndex types.CommitteeIndex
 		isProposer     bool
-		proposerSlot   uint64
+		proposerSlot   types.Slot
 	}{
 		{
 			index:          0,
 			slot:           78,
-			committee:      []uint64{0, 38},
+			committee:      []types.ValidatorIndex{0, 38},
 			committeeIndex: 0,
 			isProposer:     false,
 		},
 		{
 			index:          1,
 			slot:           71,
-			committee:      []uint64{1, 4},
+			committee:      []types.ValidatorIndex{1, 4},
 			committeeIndex: 0,
 			isProposer:     true,
 			proposerSlot:   79,
@@ -174,13 +175,13 @@ func TestCommitteeAssignments_CanRetrieve(t *testing.T) {
 		{
 			index:          11,
 			slot:           90,
-			committee:      []uint64{31, 11},
+			committee:      []types.ValidatorIndex{31, 11},
 			committeeIndex: 0,
 			isProposer:     false,
 		}, {
 			index:          2,
 			slot:           127, // 3rd epoch has more active validators
-			committee:      []uint64{89, 2, 81, 5},
+			committee:      []types.ValidatorIndex{89, 2, 81, 5},
 			committeeIndex: 0,
 			isProposer:     false,
 		},
@@ -208,7 +209,7 @@ func TestCommitteeAssignments_CannotRetrieveFuture(t *testing.T) {
 	validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch)
 	for i := 0; i < len(validators); i++ {
 		// First 2 epochs only half validators are activated.
-		var activationEpoch uint64
+		var activationEpoch types.Epoch
 		if i >= len(validators)/2 {
 			activationEpoch = 3
 		}
@@ -249,17 +250,17 @@ func TestCommitteeAssignments_EverySlotHasMin1Proposer(t *testing.T) {
 	})
 	require.NoError(t, err)
 	ClearCache()
-	epoch := uint64(1)
+	epoch := types.Epoch(1)
 	_, proposerIndexToSlots, err := CommitteeAssignments(state, epoch)
 	require.NoError(t, err, "Failed to determine CommitteeAssignments")
 
-	slotsWithProposers := make(map[uint64]bool)
+	slotsWithProposers := make(map[types.Slot]bool)
 	for _, proposerSlots := range proposerIndexToSlots {
 		for _, slot := range proposerSlots {
 			slotsWithProposers[slot] = true
 		}
 	}
-	assert.Equal(t, params.BeaconConfig().SlotsPerEpoch, uint64(len(slotsWithProposers)), "Unexpected slots")
+	assert.Equal(t, uint64(params.BeaconConfig().SlotsPerEpoch), uint64(len(slotsWithProposers)), "Unexpected slots")
 	startSlot, err := StartSlot(epoch)
 	require.NoError(t, err)
 	endSlot, err := StartSlot(epoch + 1)
@@ -287,7 +288,7 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
 
 	tests := []struct {
 		attestation         *ethpb.Attestation
-		stateSlot           uint64
+		stateSlot           types.Slot
 		verificationFailure bool
 	}{
 		{
@@ -403,8 +404,8 @@ func TestUpdateCommitteeCache_CanUpdate(t *testing.T) {
 	ClearCache()
 	validatorCount := params.BeaconConfig().MinGenesisActiveValidatorCount
 	validators := make([]*ethpb.Validator, validatorCount)
-	indices := make([]uint64, validatorCount)
-	for i := uint64(0); i < validatorCount; i++ {
+	indices := make([]types.ValidatorIndex, validatorCount)
+	for i := types.ValidatorIndex(0); uint64(i) < validatorCount; i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -417,12 +418,12 @@ func TestUpdateCommitteeCache_CanUpdate(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, UpdateCommitteeCache(state, CurrentEpoch(state)))
 
-	epoch := uint64(1)
-	idx := uint64(1)
+	epoch := types.Epoch(1)
+	idx := types.CommitteeIndex(1)
 	seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(t, err)
 
-	indices, err = committeeCache.Committee(epoch*params.BeaconConfig().SlotsPerEpoch, seed, idx)
+	indices, err = committeeCache.Committee(params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epoch)), seed, idx)
 	require.NoError(t, err)
 	assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(indices)), "Did not save correct indices lengths")
 }
@@ -602,7 +603,7 @@ func BenchmarkComputeCommittee4000000_WithOutCache(b *testing.B) {
 
 func TestBeaconCommitteeFromState_UpdateCacheForPreviousEpoch(t *testing.T) {
 	committeeSize := uint64(16)
-	validators := make([]*ethpb.Validator, committeeSize*params.BeaconConfig().SlotsPerEpoch)
+	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(committeeSize))
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
@@ -646,10 +647,10 @@ func TestPrecomputeProposerIndices_Ok(t *testing.T) {
 	proposerIndices, err := precomputeProposerIndices(state, indices)
 	require.NoError(t, err)
 
-	var wantedProposerIndices []uint64
+	var wantedProposerIndices []types.ValidatorIndex
 	seed, err := Seed(state, 0, params.BeaconConfig().DomainBeaconProposer)
 	require.NoError(t, err)
-	for i := uint64(0); i < params.BeaconConfig().SlotsPerEpoch; i++ {
+	for i := uint64(0); i < uint64(params.BeaconConfig().SlotsPerEpoch); i++ {
 		seedWithSlot := append(seed[:], bytesutil.Bytes8(i)...)
 		seedWithSlotHash := hashutil.Hash(seedWithSlot)
 		index, err := ComputeProposerIndex(state, indices, seedWithSlotHash)
@@ -658,9 +659,3 @@ func TestPrecomputeProposerIndices_Ok(t *testing.T) {
 	}
 	assert.DeepEqual(t, wantedProposerIndices, proposerIndices, "Did not precompute proposer indices correctly")
 }
-
-func TestUpdateProposerIndicesInCache_SlotOutOfBound(t *testing.T) {
-	err := UpdateProposerIndicesInCache(&beaconstate.BeaconState{}, 2)
-	want := "out of bound"
-	require.ErrorContains(t, want, err)
-}

beacon-chain/core/helpers/randao.go

@@ -1,6 +1,7 @@
 package helpers
 
 import (
+	types "github.com/prysmaticlabs/eth2-types"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
@@ -17,7 +18,7 @@ import (
 //    """
 //    mix = get_randao_mix(state, Epoch(epoch + EPOCHS_PER_HISTORICAL_VECTOR - MIN_SEED_LOOKAHEAD - 1))  # Avoid underflow
 //    return hash(domain_type + int_to_bytes(epoch, length=8) + mix)
-func Seed(state *stateTrie.BeaconState, epoch uint64, domain [bls.DomainByteLength]byte) ([32]byte, error) {
+func Seed(state *stateTrie.BeaconState, epoch types.Epoch, domain [bls.DomainByteLength]byte) ([32]byte, error) {
 	// See https://github.com/ethereum/eth2.0-specs/pull/1296 for
 	// rationale on why offset has to look down by 1.
 	lookAheadEpoch := epoch + params.BeaconConfig().EpochsPerHistoricalVector -
@@ -27,7 +28,7 @@ func Seed(state *stateTrie.BeaconState, epoch uint64, domain [bls.DomainByteLeng
 	if err != nil {
 		return [32]byte{}, err
 	}
-	seed := append(domain[:], bytesutil.Bytes8(epoch)...)
+	seed := append(domain[:], bytesutil.Bytes8(uint64(epoch))...)
 	seed = append(seed, randaoMix...)
 
 	seed32 := hashutil.Hash(seed)
@@ -44,6 +45,6 @@ func Seed(state *stateTrie.BeaconState, epoch uint64, domain [bls.DomainByteLeng
 //    Return the randao mix at a recent ``epoch``.
 //    """
 //    return state.randao_mixes[epoch % EPOCHS_PER_HISTORICAL_VECTOR]
-func RandaoMix(state *stateTrie.BeaconState, epoch uint64) ([]byte, error) {
-	return state.RandaoMixAtIndex(epoch % params.BeaconConfig().EpochsPerHistoricalVector)
+func RandaoMix(state *stateTrie.BeaconState, epoch types.Epoch) ([]byte, error) {
+	return state.RandaoMixAtIndex(uint64(epoch % params.BeaconConfig().EpochsPerHistoricalVector))
 }

beacon-chain/core/helpers/randao_test.go

@@ -4,6 +4,7 @@ import (
 	"encoding/binary"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
@@ -22,7 +23,7 @@ func TestRandaoMix_OK(t *testing.T) {
 	state, err := beaconstate.InitializeFromProto(&pb.BeaconState{RandaoMixes: randaoMixes})
 	require.NoError(t, err)
 	tests := []struct {
-		epoch     uint64
+		epoch     types.Epoch
 		randaoMix []byte
 	}{
 		{
@@ -39,7 +40,7 @@ func TestRandaoMix_OK(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		require.NoError(t, state.SetSlot((test.epoch+1)*params.BeaconConfig().SlotsPerEpoch))
+		require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch.Mul(uint64(test.epoch+1))))
 		mix, err := RandaoMix(state, test.epoch)
 		require.NoError(t, err)
 		assert.DeepEqual(t, test.randaoMix, mix, "Incorrect randao mix")
@@ -56,7 +57,7 @@ func TestRandaoMix_CopyOK(t *testing.T) {
 	state, err := beaconstate.InitializeFromProto(&pb.BeaconState{RandaoMixes: randaoMixes})
 	require.NoError(t, err)
 	tests := []struct {
-		epoch     uint64
+		epoch     types.Epoch
 		randaoMix []byte
 	}{
 		{
@@ -73,10 +74,10 @@ func TestRandaoMix_CopyOK(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		require.NoError(t, state.SetSlot((test.epoch+1)*params.BeaconConfig().SlotsPerEpoch))
+		require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch.Mul(uint64(test.epoch+1))))
 		mix, err := RandaoMix(state, test.epoch)
 		require.NoError(t, err)
-		uniqueNumber := params.BeaconConfig().EpochsPerHistoricalVector + 1000
+		uniqueNumber := uint64(params.BeaconConfig().EpochsPerHistoricalVector.Add(1000))
 		binary.LittleEndian.PutUint64(mix, uniqueNumber)
 
 		for _, mx := range randaoMixes {
@@ -93,7 +94,7 @@ func TestGenerateSeed_OK(t *testing.T) {
 		binary.LittleEndian.PutUint64(intInBytes, uint64(i))
 		randaoMixes[i] = intInBytes
 	}
-	slot := 10 * params.BeaconConfig().MinSeedLookahead * params.BeaconConfig().SlotsPerEpoch
+	slot := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().MinSeedLookahead * 10))
 	state, err := beaconstate.InitializeFromProto(&pb.BeaconState{
 		RandaoMixes: randaoMixes,
 		Slot:        slot,

beacon-chain/core/helpers/rewards_penalties.go

@@ -1,6 +1,7 @@
 package helpers
 
 import (
+	types "github.com/prysmaticlabs/eth2-types"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
@@ -15,7 +16,7 @@ import (
 //    ``EFFECTIVE_BALANCE_INCREMENT`` Gwei minimum to avoid divisions by zero.
 //    """
 //    return Gwei(max(EFFECTIVE_BALANCE_INCREMENT, sum([state.validators[index].effective_balance for index in indices])))
-func TotalBalance(state *stateTrie.BeaconState, indices []uint64) uint64 {
+func TotalBalance(state *stateTrie.BeaconState, indices []types.ValidatorIndex) uint64 {
 	total := uint64(0)
 
 	for _, idx := range indices {
@@ -64,7 +65,7 @@ func TotalActiveBalance(state *stateTrie.BeaconState) (uint64, error) {
 //    Increase the validator balance at index ``index`` by ``delta``.
 //    """
 //    state.balances[index] += delta
-func IncreaseBalance(state *stateTrie.BeaconState, idx, delta uint64) error {
+func IncreaseBalance(state *stateTrie.BeaconState, idx types.ValidatorIndex, delta uint64) error {
 	balAtIdx, err := state.BalanceAtIndex(idx)
 	if err != nil {
 		return err
@@ -94,7 +95,7 @@ func IncreaseBalanceWithVal(currBalance, delta uint64) uint64 {
 //    Decrease the validator balance at index ``index`` by ``delta``, with underflow protection.
 //    """
 //    state.balances[index] = 0 if delta > state.balances[index] else state.balances[index] - delta
-func DecreaseBalance(state *stateTrie.BeaconState, idx, delta uint64) error {
+func DecreaseBalance(state *stateTrie.BeaconState, idx types.ValidatorIndex, delta uint64) error {
 	balAtIdx, err := state.BalanceAtIndex(idx)
 	if err != nil {
 		return err

beacon-chain/core/helpers/rewards_penalties_test.go

@@ -3,6 +3,7 @@ package helpers
 import (
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -18,7 +19,7 @@ func TestTotalBalance_OK(t *testing.T) {
 	}})
 	require.NoError(t, err)
 
-	balance := TotalBalance(state, []uint64{0, 1, 2, 3})
+	balance := TotalBalance(state, []types.ValidatorIndex{0, 1, 2, 3})
 	wanted := state.Validators()[0].EffectiveBalance + state.Validators()[1].EffectiveBalance +
 		state.Validators()[2].EffectiveBalance + state.Validators()[3].EffectiveBalance
 	assert.Equal(t, wanted, balance, "Incorrect TotalBalance")
@@ -28,7 +29,7 @@ func TestTotalBalance_ReturnsEffectiveBalanceIncrement(t *testing.T) {
 	state, err := beaconstate.InitializeFromProto(&pb.BeaconState{Validators: []*ethpb.Validator{}})
 	require.NoError(t, err)
 
-	balance := TotalBalance(state, []uint64{})
+	balance := TotalBalance(state, []types.ValidatorIndex{})
 	wanted := params.BeaconConfig().EffectiveBalanceIncrement
 	assert.Equal(t, wanted, balance, "Incorrect TotalBalance")
 }
@@ -81,7 +82,7 @@ func TestGetBalance_OK(t *testing.T) {
 
 func TestIncreaseBalance_OK(t *testing.T) {
 	tests := []struct {
-		i  uint64
+		i  types.ValidatorIndex
 		b  []uint64
 		nb uint64
 		eb uint64
@@ -104,7 +105,7 @@ func TestIncreaseBalance_OK(t *testing.T) {
 
 func TestDecreaseBalance_OK(t *testing.T) {
 	tests := []struct {
-		i  uint64
+		i  types.ValidatorIndex
 		b  []uint64
 		nb uint64
 		eb uint64

beacon-chain/core/helpers/shuffle.go

@@ -4,6 +4,7 @@ import (
 	"encoding/binary"
 	"fmt"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/hashutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
@@ -34,13 +35,13 @@ func SplitIndices(l []uint64, n uint64) [][]uint64 {
 // We utilize 'swap or not' shuffling in this implementation; we are allocating the memory with the seed that stays
 // constant between iterations instead of reallocating it each iteration as in the spec. This implementation is based
 // on the original implementation from protolambda, https://github.com/protolambda/eth2-shuffle
-func ShuffledIndex(index, indexCount uint64, seed [32]byte) (uint64, error) {
+func ShuffledIndex(index types.ValidatorIndex, indexCount uint64, seed [32]byte) (types.ValidatorIndex, error) {
 	return ComputeShuffledIndex(index, indexCount, seed, true /* shuffle */)
 }
 
 // UnShuffledIndex returns the inverse of ShuffledIndex. This implementation is based
 // on the original implementation from protolambda, https://github.com/protolambda/eth2-shuffle
-func UnShuffledIndex(index, indexCount uint64, seed [32]byte) (uint64, error) {
+func UnShuffledIndex(index types.ValidatorIndex, indexCount uint64, seed [32]byte) (types.ValidatorIndex, error) {
 	return ComputeShuffledIndex(index, indexCount, seed, false /* un-shuffle */)
 }
 
@@ -64,11 +65,11 @@ func UnShuffledIndex(index, indexCount uint64, seed [32]byte) (uint64, error) {
 //        index = flip if bit else index
 //
 //    return ValidatorIndex(index)
-func ComputeShuffledIndex(index, indexCount uint64, seed [32]byte, shuffle bool) (uint64, error) {
+func ComputeShuffledIndex(index types.ValidatorIndex, indexCount uint64, seed [32]byte, shuffle bool) (types.ValidatorIndex, error) {
 	if params.BeaconConfig().ShuffleRoundCount == 0 {
 		return index, nil
 	}
-	if index >= indexCount {
+	if uint64(index) >= indexCount {
 		return 0, fmt.Errorf("input index %d out of bounds: %d",
 			index, indexCount)
 	}
@@ -95,9 +96,9 @@ func ComputeShuffledIndex(index, indexCount uint64, seed [32]byte, shuffle bool)
 		hash8 := hash[:8]
 		hash8Int := bytesutil.FromBytes8(hash8)
 		pivot := hash8Int % indexCount
-		flip := (pivot + indexCount - index) % indexCount
+		flip := (pivot + indexCount - uint64(index)) % indexCount
 		// Consider every pair only once by picking the highest pair index to retrieve randomness.
-		position := index
+		position := uint64(index)
 		if flip > position {
 			position = flip
 		}
@@ -113,7 +114,7 @@ func ComputeShuffledIndex(index, indexCount uint64, seed [32]byte, shuffle bool)
 		bitV := (byteV >> (position & 0x7)) & 0x1
 		// index = flip if bit else index
 		if bitV == 1 {
-			index = flip
+			index = types.ValidatorIndex(flip)
 		}
 		if shuffle {
 			round++
@@ -144,17 +145,17 @@ func ComputeShuffledIndex(index, indexCount uint64, seed [32]byte, shuffle bool)
 //   - change byteV every 8 iterations.
 //   - we start at the edges, and work back to the mirror point.
 //     this makes us process each pear exactly once (instead of unnecessarily twice, like in the spec).
-func ShuffleList(input []uint64, seed [32]byte) ([]uint64, error) {
+func ShuffleList(input []types.ValidatorIndex, seed [32]byte) ([]types.ValidatorIndex, error) {
 	return innerShuffleList(input, seed, true /* shuffle */)
 }
 
 // UnshuffleList un-shuffles the list by running backwards through the round count.
-func UnshuffleList(input []uint64, seed [32]byte) ([]uint64, error) {
+func UnshuffleList(input []types.ValidatorIndex, seed [32]byte) ([]types.ValidatorIndex, error) {
 	return innerShuffleList(input, seed, false /* un-shuffle */)
 }
 
 // shuffles or unshuffles, shuffle=false to un-shuffle.
-func innerShuffleList(input []uint64, seed [32]byte, shuffle bool) ([]uint64, error) {
+func innerShuffleList(input []types.ValidatorIndex, seed [32]byte, shuffle bool) ([]types.ValidatorIndex, error) {
 	if len(input) <= 1 {
 		return input, nil
 	}
@@ -183,7 +184,7 @@ func innerShuffleList(input []uint64, seed [32]byte, shuffle bool) ([]uint64, er
 		source := hashfunc(buf)
 		byteV := source[(pivot&0xff)>>3]
 		for i, j := uint64(0), pivot; i < mirror; i, j = i+1, j-1 {
-			byteV, source = swapOrNot(buf, byteV, i, input, j, source, hashfunc)
+			byteV, source = swapOrNot(buf, byteV, types.ValidatorIndex(i), input, types.ValidatorIndex(j), source, hashfunc)
 		}
 		// Now repeat, but for the part after the pivot.
 		mirror = (pivot + listSize + 1) >> 1
@@ -192,7 +193,7 @@ func innerShuffleList(input []uint64, seed [32]byte, shuffle bool) ([]uint64, er
 		source = hashfunc(buf)
 		byteV = source[(end&0xff)>>3]
 		for i, j := pivot+1, end; i < mirror; i, j = i+1, j-1 {
-			byteV, source = swapOrNot(buf, byteV, i, input, j, source, hashfunc)
+			byteV, source = swapOrNot(buf, byteV, types.ValidatorIndex(i), input, types.ValidatorIndex(j), source, hashfunc)
 		}
 		if shuffle {
 			r++
@@ -211,8 +212,8 @@ func innerShuffleList(input []uint64, seed [32]byte, shuffle bool) ([]uint64, er
 
 // swapOrNot describes the main algorithm behind the shuffle where we swap bytes in the inputted value
 // depending on if the conditions are met.
-func swapOrNot(buf []byte, byteV byte, i uint64, input []uint64,
-	j uint64, source [32]byte, hashFunc func([]byte) [32]byte) (byte, [32]byte) {
+func swapOrNot(buf []byte, byteV byte, i types.ValidatorIndex, input []types.ValidatorIndex,
+	j types.ValidatorIndex, source [32]byte, hashFunc func([]byte) [32]byte) (byte, [32]byte) {
 	if j&0xff == 0xff {
 		// just overwrite the last part of the buffer, reuse the start (seed, round)
 		binary.LittleEndian.PutUint32(buf[pivotViewSize:], uint32(j>>8))

beacon-chain/core/helpers/shuffle_test.go

@@ -5,6 +5,7 @@ import (
 	"reflect"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/sliceutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
@@ -13,7 +14,7 @@ import (
 
 func TestShuffleList_InvalidValidatorCount(t *testing.T) {
 	maxShuffleListSize = 20
-	list := make([]uint64, 21)
+	list := make([]types.ValidatorIndex, 21)
 	if _, err := ShuffleList(list, [32]byte{123, 125}); err == nil {
 		t.Error("Shuffle should have failed when validator count exceeds ModuloBias")
 		maxShuffleListSize = 1 << 40
@@ -22,14 +23,14 @@ func TestShuffleList_InvalidValidatorCount(t *testing.T) {
 }
 
 func TestShuffleList_OK(t *testing.T) {
-	var list1 []uint64
+	var list1 []types.ValidatorIndex
 	seed1 := [32]byte{1, 128, 12}
 	seed2 := [32]byte{2, 128, 12}
 	for i := 0; i < 10; i++ {
-		list1 = append(list1, uint64(i))
+		list1 = append(list1, types.ValidatorIndex(i))
 	}
 
-	list2 := make([]uint64, len(list1))
+	list2 := make([]types.ValidatorIndex, len(list1))
 	copy(list2, list1)
 
 	list1, err := ShuffleList(list1, seed1)
@@ -41,8 +42,8 @@ func TestShuffleList_OK(t *testing.T) {
 	if reflect.DeepEqual(list1, list2) {
 		t.Errorf("2 shuffled lists shouldn't be equal")
 	}
-	assert.DeepEqual(t, []uint64{0, 7, 8, 6, 3, 9, 4, 5, 2, 1}, list1, "List 1 was incorrectly shuffled got")
-	assert.DeepEqual(t, []uint64{0, 5, 2, 1, 6, 8, 7, 3, 4, 9}, list2, "List 2 was incorrectly shuffled got")
+	assert.DeepEqual(t, []types.ValidatorIndex{0, 7, 8, 6, 3, 9, 4, 5, 2, 1}, list1, "List 1 was incorrectly shuffled got")
+	assert.DeepEqual(t, []types.ValidatorIndex{0, 5, 2, 1, 6, 8, 7, 3, 4, 9}, list2, "List 2 was incorrectly shuffled got")
 }
 
 func TestSplitIndices_OK(t *testing.T) {
@@ -51,23 +52,23 @@ func TestSplitIndices_OK(t *testing.T) {
 	for i := uint64(0); i < numValidators; i++ {
 		l = append(l, i)
 	}
-	split := SplitIndices(l, params.BeaconConfig().SlotsPerEpoch)
-	assert.Equal(t, params.BeaconConfig().SlotsPerEpoch, uint64(len(split)), "Split list failed due to incorrect length")
+	split := SplitIndices(l, uint64(params.BeaconConfig().SlotsPerEpoch))
+	assert.Equal(t, uint64(params.BeaconConfig().SlotsPerEpoch), uint64(len(split)), "Split list failed due to incorrect length")
 
 	for _, s := range split {
-		assert.Equal(t, numValidators/params.BeaconConfig().SlotsPerEpoch, uint64(len(s)), "Split list failed due to incorrect length")
+		assert.Equal(t, numValidators/uint64(params.BeaconConfig().SlotsPerEpoch), uint64(len(s)), "Split list failed due to incorrect length")
 	}
 }
 
 func TestShuffleList_Vs_ShuffleIndex(t *testing.T) {
-	var list []uint64
+	var list []types.ValidatorIndex
 	listSize := uint64(1000)
 	seed := [32]byte{123, 42}
-	for i := uint64(0); i < listSize; i++ {
+	for i := types.ValidatorIndex(0); uint64(i) < listSize; i++ {
 		list = append(list, i)
 	}
-	shuffledListByIndex := make([]uint64, listSize)
-	for i := uint64(0); i < listSize; i++ {
+	shuffledListByIndex := make([]types.ValidatorIndex, listSize)
+	for i := types.ValidatorIndex(0); uint64(i) < listSize; i++ {
 		si, err := ShuffledIndex(i, listSize, seed)
 		assert.NoError(t, err)
 		shuffledListByIndex[si] = i
@@ -83,7 +84,7 @@ func BenchmarkShuffledIndex(b *testing.B) {
 	for _, listSize := range listSizes {
 		b.Run(fmt.Sprintf("ShuffledIndex_%d", listSize), func(ib *testing.B) {
 			for i := uint64(0); i < uint64(ib.N); i++ {
-				_, err := ShuffledIndex(i%listSize, listSize, seed)
+				_, err := ShuffledIndex(types.ValidatorIndex(i%listSize), listSize, seed)
 				assert.NoError(b, err)
 			}
 		})
@@ -97,7 +98,7 @@ func BenchmarkIndexComparison(b *testing.B) {
 		b.Run(fmt.Sprintf("Indexwise_ShuffleList_%d", listSize), func(ib *testing.B) {
 			for i := 0; i < ib.N; i++ {
 				// Simulate a list-shuffle by running shuffle-index listSize times.
-				for j := uint64(0); j < listSize; j++ {
+				for j := types.ValidatorIndex(0); uint64(j) < listSize; j++ {
 					_, err := ShuffledIndex(j, listSize, seed)
 					assert.NoError(b, err)
 				}
@@ -110,9 +111,9 @@ func BenchmarkShuffleList(b *testing.B) {
 	listSizes := []uint64{400000, 40000, 400}
 	seed := [32]byte{123, 42}
 	for _, listSize := range listSizes {
-		testIndices := make([]uint64, listSize)
+		testIndices := make([]types.ValidatorIndex, listSize)
 		for i := uint64(0); i < listSize; i++ {
-			testIndices[i] = i
+			testIndices[i] = types.ValidatorIndex(i)
 		}
 		b.Run(fmt.Sprintf("ShuffleList_%d", listSize), func(ib *testing.B) {
 			for i := 0; i < ib.N; i++ {
@@ -124,25 +125,25 @@ func BenchmarkShuffleList(b *testing.B) {
 }
 
 func TestShuffledIndex(t *testing.T) {
-	var list []uint64
+	var list []types.ValidatorIndex
 	listSize := uint64(399)
-	for i := uint64(0); i < listSize; i++ {
+	for i := types.ValidatorIndex(0); uint64(i) < listSize; i++ {
 		list = append(list, i)
 	}
-	shuffledList := make([]uint64, listSize)
-	unShuffledList := make([]uint64, listSize)
+	shuffledList := make([]types.ValidatorIndex, listSize)
+	unshuffledlist := make([]types.ValidatorIndex, listSize)
 	seed := [32]byte{123, 42}
-	for i := uint64(0); i < listSize; i++ {
+	for i := types.ValidatorIndex(0); uint64(i) < listSize; i++ {
 		si, err := ShuffledIndex(i, listSize, seed)
 		assert.NoError(t, err)
 		shuffledList[si] = i
 	}
-	for i := uint64(0); i < listSize; i++ {
+	for i := types.ValidatorIndex(0); uint64(i) < listSize; i++ {
 		ui, err := UnShuffledIndex(i, listSize, seed)
 		assert.NoError(t, err)
-		unShuffledList[ui] = shuffledList[i]
+		unshuffledlist[ui] = shuffledList[i]
 	}
-	assert.DeepEqual(t, list, unShuffledList)
+	assert.DeepEqual(t, list, unshuffledlist)
 }
 
 func TestSplitIndicesAndOffset_OK(t *testing.T) {

beacon-chain/core/helpers/signing_root.go

@@ -3,6 +3,7 @@ package helpers
 import (
 	fssz "github.com/ferranbt/fastssz"
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -22,7 +23,7 @@ const DomainByteLength = 4
 var ErrSigFailedToVerify = errors.New("signature did not verify")
 
 // ComputeDomainAndSign computes the domain and signing root and sign it using the passed in private key.
-func ComputeDomainAndSign(st *state.BeaconState, epoch uint64, obj fssz.HashRoot, domain [4]byte, key bls.SecretKey) ([]byte, error) {
+func ComputeDomainAndSign(st *state.BeaconState, epoch types.Epoch, obj fssz.HashRoot, domain [4]byte, key bls.SecretKey) ([]byte, error) {
 	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorRoot())
 	if err != nil {
 		return nil, err
@@ -64,7 +65,7 @@ func signingData(rootFunc func() ([32]byte, error), domain []byte) ([32]byte, er
 }
 
 // ComputeDomainVerifySigningRoot computes domain and verifies signing root of an object given the beacon state, validator index and signature.
-func ComputeDomainVerifySigningRoot(st *state.BeaconState, index, epoch uint64, obj fssz.HashRoot, domain [4]byte, sig []byte) error {
+func ComputeDomainVerifySigningRoot(st *state.BeaconState, index types.ValidatorIndex, epoch types.Epoch, obj fssz.HashRoot, domain [4]byte, sig []byte) error {
 	v, err := st.ValidatorAtIndex(index)
 	if err != nil {
 		return err

beacon-chain/core/helpers/slot_epoch.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/mathutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
@@ -24,8 +25,8 @@ const MaxSlotBuffer = uint64(1 << 7)
 //    Return the epoch number of ``slot``.
 //    """
 //    return Epoch(slot // SLOTS_PER_EPOCH)
-func SlotToEpoch(slot uint64) uint64 {
-	return slot / params.BeaconConfig().SlotsPerEpoch
+func SlotToEpoch(slot types.Slot) types.Epoch {
+	return types.Epoch(slot.DivSlot(params.BeaconConfig().SlotsPerEpoch))
 }
 
 // CurrentEpoch returns the current epoch number calculated from
@@ -37,7 +38,7 @@ func SlotToEpoch(slot uint64) uint64 {
 //    Return the current epoch.
 //    """
 //    return compute_epoch_of_slot(state.slot)
-func CurrentEpoch(state *stateTrie.BeaconState) uint64 {
+func CurrentEpoch(state *stateTrie.BeaconState) types.Epoch {
 	return SlotToEpoch(state.Slot())
 }
 
@@ -52,7 +53,7 @@ func CurrentEpoch(state *stateTrie.BeaconState) uint64 {
 //    """
 //    current_epoch = get_current_epoch(state)
 //    return GENESIS_EPOCH if current_epoch == GENESIS_EPOCH else Epoch(current_epoch - 1)
-func PrevEpoch(state *stateTrie.BeaconState) uint64 {
+func PrevEpoch(state *stateTrie.BeaconState) types.Epoch {
 	currentEpoch := CurrentEpoch(state)
 	if currentEpoch == 0 {
 		return 0
@@ -62,7 +63,7 @@ func PrevEpoch(state *stateTrie.BeaconState) uint64 {
 
 // NextEpoch returns the next epoch number calculated from
 // the slot number stored in beacon state.
-func NextEpoch(state *stateTrie.BeaconState) uint64 {
+func NextEpoch(state *stateTrie.BeaconState) types.Epoch {
 	return SlotToEpoch(state.Slot()) + 1
 }
 
@@ -75,8 +76,8 @@ func NextEpoch(state *stateTrie.BeaconState) uint64 {
 //    Return the start slot of ``epoch``.
 //    """
 //    return Slot(epoch * SLOTS_PER_EPOCH)
-func StartSlot(epoch uint64) (uint64, error) {
-	slot, err := mathutil.Mul64(epoch, params.BeaconConfig().SlotsPerEpoch)
+func StartSlot(epoch types.Epoch) (types.Slot, error) {
+	slot, err := params.BeaconConfig().SlotsPerEpoch.SafeMul(uint64(epoch))
 	if err != nil {
 		return slot, errors.Errorf("start slot calculation overflows: %v", err)
 	}
@@ -85,7 +86,7 @@ func StartSlot(epoch uint64) (uint64, error) {
 
 // EndSlot returns the last slot number of the
 // current epoch.
-func EndSlot(epoch uint64) (uint64, error) {
+func EndSlot(epoch types.Epoch) (types.Slot, error) {
 	if epoch == math.MaxUint64 {
 		return 0, errors.New("start slot calculation overflows")
 	}
@@ -98,23 +99,23 @@ func EndSlot(epoch uint64) (uint64, error) {
 
 // IsEpochStart returns true if the given slot number is an epoch starting slot
 // number.
-func IsEpochStart(slot uint64) bool {
+func IsEpochStart(slot types.Slot) bool {
 	return slot%params.BeaconConfig().SlotsPerEpoch == 0
 }
 
 // IsEpochEnd returns true if the given slot number is an epoch ending slot
 // number.
-func IsEpochEnd(slot uint64) bool {
+func IsEpochEnd(slot types.Slot) bool {
 	return IsEpochStart(slot + 1)
 }
 
 // SlotsSinceEpochStarts returns number of slots since the start of the epoch.
-func SlotsSinceEpochStarts(slot uint64) uint64 {
+func SlotsSinceEpochStarts(slot types.Slot) types.Slot {
 	return slot % params.BeaconConfig().SlotsPerEpoch
 }
 
 // VerifySlotTime validates the input slot is not from the future.
-func VerifySlotTime(genesisTime, slot uint64, timeTolerance time.Duration) error {
+func VerifySlotTime(genesisTime uint64, slot types.Slot, timeTolerance time.Duration) error {
 	slotTime, err := SlotToTime(genesisTime, slot)
 	if err != nil {
 		return err
@@ -136,12 +137,12 @@ func VerifySlotTime(genesisTime, slot uint64, timeTolerance time.Duration) error
 }
 
 // SlotToTime takes the given slot and genesis time to determine the start time of the slot.
-func SlotToTime(genesisTimeSec, slot uint64) (time.Time, error) {
-	timeSinceGenesis, err := mathutil.Mul64(slot, params.BeaconConfig().SecondsPerSlot)
+func SlotToTime(genesisTimeSec uint64, slot types.Slot) (time.Time, error) {
+	timeSinceGenesis, err := slot.SafeMul(params.BeaconConfig().SecondsPerSlot)
 	if err != nil {
 		return time.Unix(0, 0), fmt.Errorf("slot (%d) is in the far distant future: %w", slot, err)
 	}
-	sTime, err := mathutil.Add64(genesisTimeSec, timeSinceGenesis)
+	sTime, err := timeSinceGenesis.SafeAdd(genesisTimeSec)
 	if err != nil {
 		return time.Unix(0, 0), fmt.Errorf("slot (%d) is in the far distant future: %w", slot, err)
 	}
@@ -149,26 +150,26 @@ func SlotToTime(genesisTimeSec, slot uint64) (time.Time, error) {
 }
 
 // SlotsSince computes the number of time slots that have occurred since the given timestamp.
-func SlotsSince(time time.Time) uint64 {
+func SlotsSince(time time.Time) types.Slot {
 	return CurrentSlot(uint64(time.Unix()))
 }
 
 // CurrentSlot returns the current slot as determined by the local clock and
 // provided genesis time.
-func CurrentSlot(genesisTimeSec uint64) uint64 {
+func CurrentSlot(genesisTimeSec uint64) types.Slot {
 	now := timeutils.Now().Unix()
 	genesis := int64(genesisTimeSec)
 	if now < genesis {
 		return 0
 	}
-	return uint64(now-genesis) / params.BeaconConfig().SecondsPerSlot
+	return types.Slot(uint64(now-genesis) / params.BeaconConfig().SecondsPerSlot)
 }
 
 // ValidateSlotClock validates a provided slot against the local
 // clock to ensure slots that are unreasonable are returned with
 // an error.
-func ValidateSlotClock(slot, genesisTimeSec uint64) error {
-	maxPossibleSlot := CurrentSlot(genesisTimeSec) + MaxSlotBuffer
+func ValidateSlotClock(slot types.Slot, genesisTimeSec uint64) error {
+	maxPossibleSlot := CurrentSlot(genesisTimeSec).Add(MaxSlotBuffer)
 	// Defensive check to ensure that we only process slots up to a hard limit
 	// from our local clock.
 	if slot > maxPossibleSlot {
@@ -178,7 +179,7 @@ func ValidateSlotClock(slot, genesisTimeSec uint64) error {
 }
 
 // RoundUpToNearestEpoch rounds up the provided slot value to the nearest epoch.
-func RoundUpToNearestEpoch(slot uint64) uint64 {
+func RoundUpToNearestEpoch(slot types.Slot) types.Slot {
 	if slot%params.BeaconConfig().SlotsPerEpoch != 0 {
 		slot -= slot % params.BeaconConfig().SlotsPerEpoch
 		slot += params.BeaconConfig().SlotsPerEpoch
@@ -199,7 +200,7 @@ func RoundUpToNearestEpoch(slot uint64) uint64 {
 //    else:
 //        weak_subjectivity_period += SAFETY_DECAY*val_count/(2*100*MIN_PER_EPOCH_CHURN_LIMIT)
 //    return weak_subjectivity_period
-func WeakSubjectivityCheckptEpoch(valCount uint64) (uint64, error) {
+func WeakSubjectivityCheckptEpoch(valCount uint64) (types.Epoch, error) {
 	wsp := params.BeaconConfig().MinValidatorWithdrawabilityDelay
 
 	m := params.BeaconConfig().MinPerEpochChurnLimit
@@ -207,24 +208,22 @@ func WeakSubjectivityCheckptEpoch(valCount uint64) (uint64, error) {
 	d := params.BeaconConfig().SafetyDecay
 	if valCount >= m*q {
 		v := d * q / (2 * 100)
-		wsp += v
+		wsp += types.Epoch(v)
 	} else {
 		v, err := mathutil.Mul64(d, valCount)
 		if err != nil {
 			return 0, err
 		}
 		v /= 2 * 100 * m
-		wsp += v
+		wsp += types.Epoch(v)
 	}
 	return wsp, nil
 }
 
 // VotingPeriodStartTime returns the current voting period's start time
 // depending on the provided genesis and current slot.
-func VotingPeriodStartTime(genesis, slot uint64) uint64 {
-	startTime := genesis
-	startTime +=
-		(slot - (slot % (params.BeaconConfig().EpochsPerEth1VotingPeriod * params.BeaconConfig().SlotsPerEpoch))) *
-			params.BeaconConfig().SecondsPerSlot
-	return startTime
+func VotingPeriodStartTime(genesis uint64, slot types.Slot) uint64 {
+	slots := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().EpochsPerEth1VotingPeriod))
+	startTime := uint64((slot - slot.ModSlot(slots)).Mul(params.BeaconConfig().SecondsPerSlot))
+	return genesis + startTime
 }

beacon-chain/core/helpers/slot_epoch_test.go

@@ -5,19 +5,19 @@ import (
 	"testing"
 	"time"
 
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
-	"github.com/prysmaticlabs/prysm/shared/timeutils"
-
+	types "github.com/prysmaticlabs/eth2-types"
 	beaconstate "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/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
 )
 
 func TestSlotToEpoch_OK(t *testing.T) {
 	tests := []struct {
-		slot  uint64
-		epoch uint64
+		slot  types.Slot
+		epoch types.Epoch
 	}{
 		{slot: 0, epoch: 0},
 		{slot: 50, epoch: 1},
@@ -32,8 +32,8 @@ func TestSlotToEpoch_OK(t *testing.T) {
 
 func TestCurrentEpoch_OK(t *testing.T) {
 	tests := []struct {
-		slot  uint64
-		epoch uint64
+		slot  types.Slot
+		epoch types.Epoch
 	}{
 		{slot: 0, epoch: 0},
 		{slot: 50, epoch: 1},
@@ -50,8 +50,8 @@ func TestCurrentEpoch_OK(t *testing.T) {
 
 func TestPrevEpoch_OK(t *testing.T) {
 	tests := []struct {
-		slot  uint64
-		epoch uint64
+		slot  types.Slot
+		epoch types.Epoch
 	}{
 		{slot: 0, epoch: 0},
 		{slot: 0 + params.BeaconConfig().SlotsPerEpoch + 1, epoch: 0},
@@ -66,14 +66,14 @@ func TestPrevEpoch_OK(t *testing.T) {
 
 func TestNextEpoch_OK(t *testing.T) {
 	tests := []struct {
-		slot  uint64
-		epoch uint64
+		slot  types.Slot
+		epoch types.Epoch
 	}{
-		{slot: 0, epoch: 0/params.BeaconConfig().SlotsPerEpoch + 1},
-		{slot: 50, epoch: 0/params.BeaconConfig().SlotsPerEpoch + 2},
-		{slot: 64, epoch: 64/params.BeaconConfig().SlotsPerEpoch + 1},
-		{slot: 128, epoch: 128/params.BeaconConfig().SlotsPerEpoch + 1},
-		{slot: 200, epoch: 200/params.BeaconConfig().SlotsPerEpoch + 1},
+		{slot: 0, epoch: types.Epoch(0/params.BeaconConfig().SlotsPerEpoch + 1)},
+		{slot: 50, epoch: types.Epoch(0/params.BeaconConfig().SlotsPerEpoch + 2)},
+		{slot: 64, epoch: types.Epoch(64/params.BeaconConfig().SlotsPerEpoch + 1)},
+		{slot: 128, epoch: types.Epoch(128/params.BeaconConfig().SlotsPerEpoch + 1)},
+		{slot: 200, epoch: types.Epoch(200/params.BeaconConfig().SlotsPerEpoch + 1)},
 	}
 	for _, tt := range tests {
 		state, err := beaconstate.InitializeFromProto(&pb.BeaconState{Slot: tt.slot})
@@ -84,8 +84,8 @@ func TestNextEpoch_OK(t *testing.T) {
 
 func TestEpochStartSlot_OK(t *testing.T) {
 	tests := []struct {
-		epoch     uint64
-		startSlot uint64
+		epoch     types.Epoch
+		startSlot types.Slot
 		error     bool
 	}{
 		{epoch: 0, startSlot: 0 * params.BeaconConfig().SlotsPerEpoch, error: false},
@@ -108,8 +108,8 @@ func TestEpochStartSlot_OK(t *testing.T) {
 
 func TestEpochEndSlot_OK(t *testing.T) {
 	tests := []struct {
-		epoch     uint64
-		startSlot uint64
+		epoch     types.Epoch
+		startSlot types.Slot
 		error     bool
 	}{
 		{epoch: 0, startSlot: 1*params.BeaconConfig().SlotsPerEpoch - 1, error: false},
@@ -134,7 +134,7 @@ func TestIsEpochStart(t *testing.T) {
 	epochLength := params.BeaconConfig().SlotsPerEpoch
 
 	tests := []struct {
-		slot   uint64
+		slot   types.Slot
 		result bool
 	}{
 		{
@@ -164,7 +164,7 @@ func TestIsEpochEnd(t *testing.T) {
 	epochLength := params.BeaconConfig().SlotsPerEpoch
 
 	tests := []struct {
-		slot   uint64
+		slot   types.Slot
 		result bool
 	}{
 		{
@@ -188,8 +188,8 @@ func TestIsEpochEnd(t *testing.T) {
 
 func TestSlotsSinceEpochStarts(t *testing.T) {
 	tests := []struct {
-		slots       uint64
-		wantedSlots uint64
+		slots       types.Slot
+		wantedSlots types.Slot
 	}{
 		{slots: 0, wantedSlots: 0},
 		{slots: 1, wantedSlots: 1},
@@ -204,8 +204,8 @@ func TestSlotsSinceEpochStarts(t *testing.T) {
 
 func TestRoundUpToNearestEpoch_OK(t *testing.T) {
 	tests := []struct {
-		startSlot     uint64
-		roundedUpSlot uint64
+		startSlot     types.Slot
+		roundedUpSlot types.Slot
 	}{
 		{startSlot: 0 * params.BeaconConfig().SlotsPerEpoch, roundedUpSlot: 0},
 		{startSlot: 1*params.BeaconConfig().SlotsPerEpoch - 10, roundedUpSlot: 1 * params.BeaconConfig().SlotsPerEpoch},
@@ -219,7 +219,7 @@ func TestRoundUpToNearestEpoch_OK(t *testing.T) {
 func TestSlotToTime(t *testing.T) {
 	type args struct {
 		genesisTimeSec uint64
-		slot           uint64
+		slot           types.Slot
 	}
 	tests := []struct {
 		name      string
@@ -276,7 +276,7 @@ func TestSlotToTime(t *testing.T) {
 func TestVerifySlotTime(t *testing.T) {
 	type args struct {
 		genesisTime   int64
-		slot          uint64
+		slot          types.Slot
 		timeTolerance time.Duration
 	}
 	tests := []struct {
@@ -310,7 +310,7 @@ func TestVerifySlotTime(t *testing.T) {
 			name: "max future slot",
 			args: args{
 				genesisTime: timeutils.Now().Add(-1 * 5 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second).Unix(),
-				slot:        MaxSlotBuffer + 6,
+				slot:        types.Slot(MaxSlotBuffer + 6),
 			},
 			wantedErr: "exceeds max allowed value relative to the local clock",
 		},
@@ -320,7 +320,7 @@ func TestVerifySlotTime(t *testing.T) {
 				genesisTime: timeutils.Now().Add(-1 * 24 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second).Unix(), // 24 slots in the past
 				// Gets multiplied with slot duration, and results in an overflow. Wraps around to a valid time.
 				// Lower than max signed int. And chosen specifically to wrap to a valid slot 24
-				slot: ((^uint64(0)) / params.BeaconConfig().SecondsPerSlot) + 24,
+				slot: types.Slot((^uint64(0))/params.BeaconConfig().SecondsPerSlot) + 24,
 			},
 			wantedErr: "is in the far distant future",
 		},
@@ -340,16 +340,16 @@ func TestVerifySlotTime(t *testing.T) {
 func TestValidateSlotClock_HandlesBadSlot(t *testing.T) {
 	genTime := timeutils.Now().Add(-1 * time.Duration(MaxSlotBuffer) * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second).Unix()
 
-	assert.NoError(t, ValidateSlotClock(MaxSlotBuffer, uint64(genTime)), "unexpected error validating slot")
-	assert.NoError(t, ValidateSlotClock(2*MaxSlotBuffer, uint64(genTime)), "unexpected error validating slot")
-	assert.ErrorContains(t, "which exceeds max allowed value relative to the local clock", ValidateSlotClock(2*MaxSlotBuffer+1, uint64(genTime)), "no error from bad slot")
+	assert.NoError(t, ValidateSlotClock(types.Slot(MaxSlotBuffer), uint64(genTime)), "unexpected error validating slot")
+	assert.NoError(t, ValidateSlotClock(types.Slot(2*MaxSlotBuffer), uint64(genTime)), "unexpected error validating slot")
+	assert.ErrorContains(t, "which exceeds max allowed value relative to the local clock", ValidateSlotClock(types.Slot(2*MaxSlotBuffer+1), uint64(genTime)), "no error from bad slot")
 	assert.ErrorContains(t, "which exceeds max allowed value relative to the local clock", ValidateSlotClock(1<<63, uint64(genTime)), "no error from bad slot")
 }
 
 func TestWeakSubjectivityCheckptEpoch(t *testing.T) {
 	tests := []struct {
 		valCount uint64
-		want     uint64
+		want     types.Epoch
 	}{
 		// Verifying these numbers aligned with the reference table defined:
 		// https://github.com/ethereum/eth2.0-specs/blob/weak-subjectivity-guide/specs/phase0/weak-subjectivity.md#calculating-the-weak-subjectivity-period

beacon-chain/core/helpers/spectest/BUILD.bazel

@@ -6,6 +6,7 @@ go_library(
     srcs = ["shuffle_test_format.go"],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/helpers/spectest",
     visibility = ["//beacon-chain:__subpackages__"],
+    deps = ["@com_github_prysmaticlabs_eth2_types//:go_default_library"],
 )
 
 go_test(
@@ -25,5 +26,6 @@ go_test(
         "//shared/testutil/require:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_go_yaml_yaml//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
     ],
 )

beacon-chain/core/helpers/spectest/shuffle_test_format.go

@@ -1,8 +1,10 @@
 package spectest
 
+import types "github.com/prysmaticlabs/eth2-types"
+
 // ShuffleTestCase --
 type ShuffleTestCase struct {
-	Seed    string   `yaml:"seed"`
-	Count   uint64   `yaml:"count"`
-	Mapping []uint64 `yaml:"mapping"`
+	Seed    string                 `yaml:"seed"`
+	Count   uint64                 `yaml:"count"`
+	Mapping []types.ValidatorIndex `yaml:"mapping"`
 }

beacon-chain/core/helpers/spectest/shuffle_yaml_test.go

@@ -4,13 +4,12 @@ package spectest
 
 import (
 	"encoding/hex"
-	"fmt"
 	"path"
-	"reflect"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/go-yaml/yaml"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/shared/params/spectest"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
@@ -36,34 +35,32 @@ func runShuffleTests(t *testing.T, config string) {
 
 			testCase := &ShuffleTestCase{}
 			require.NoError(t, yaml.Unmarshal(testCaseFile, testCase), "Could not unmarshal YAML file into test struct")
-			require.NoError(t, runShuffleTest(testCase), "Shuffle test failed")
+			require.NoError(t, runShuffleTest(t, testCase), "Shuffle test failed")
 		})
 	}
 }
 
 // RunShuffleTest uses validator set specified from a YAML file, runs the validator shuffle
 // algorithm, then compare the output with the expected output from the YAML file.
-func runShuffleTest(testCase *ShuffleTestCase) error {
+func runShuffleTest(t *testing.T, testCase *ShuffleTestCase) error {
 	baseSeed, err := hex.DecodeString(testCase.Seed[2:])
 	if err != nil {
 		return err
 	}
 
 	seed := common.BytesToHash(baseSeed)
-	testIndices := make([]uint64, testCase.Count)
-	for i := uint64(0); i < testCase.Count; i++ {
+	testIndices := make([]types.ValidatorIndex, testCase.Count)
+	for i := types.ValidatorIndex(0); uint64(i) < testCase.Count; i++ {
 		testIndices[i] = i
 	}
-	shuffledList := make([]uint64, testCase.Count)
-	for i := uint64(0); i < testCase.Count; i++ {
+	shuffledList := make([]types.ValidatorIndex, testCase.Count)
+	for i := types.ValidatorIndex(0); uint64(i) < testCase.Count; i++ {
 		si, err := helpers.ShuffledIndex(i, testCase.Count, seed)
 		if err != nil {
 			return err
 		}
 		shuffledList[i] = si
 	}
-	if !reflect.DeepEqual(shuffledList, testCase.Mapping) {
-		return fmt.Errorf("shuffle result error: expected %v, actual %v", testCase.Mapping, shuffledList)
-	}
+	require.DeepSSZEqual(t, shuffledList, testCase.Mapping)
 	return nil
 }

beacon-chain/core/helpers/validators.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -22,16 +23,16 @@ import (
 //    Check if ``validator`` is active.
 //    """
 //    return validator.activation_epoch <= epoch < validator.exit_epoch
-func IsActiveValidator(validator *ethpb.Validator, epoch uint64) bool {
+func IsActiveValidator(validator *ethpb.Validator, epoch types.Epoch) bool {
 	return checkValidatorActiveStatus(validator.ActivationEpoch, validator.ExitEpoch, epoch)
 }
 
 // IsActiveValidatorUsingTrie checks if a read only validator is active.
-func IsActiveValidatorUsingTrie(validator stateTrie.ReadOnlyValidator, epoch uint64) bool {
+func IsActiveValidatorUsingTrie(validator stateTrie.ReadOnlyValidator, epoch types.Epoch) bool {
 	return checkValidatorActiveStatus(validator.ActivationEpoch(), validator.ExitEpoch(), epoch)
 }
 
-func checkValidatorActiveStatus(activationEpoch, exitEpoch, epoch uint64) bool {
+func checkValidatorActiveStatus(activationEpoch, exitEpoch, epoch types.Epoch) bool {
 	return activationEpoch <= epoch && epoch < exitEpoch
 }
 
@@ -44,16 +45,16 @@ func checkValidatorActiveStatus(activationEpoch, exitEpoch, epoch uint64) bool {
 //  Check if ``validator`` is slashable.
 //  """
 //  return (not validator.slashed) and (validator.activation_epoch <= epoch < validator.withdrawable_epoch)
-func IsSlashableValidator(activationEpoch, withdrawableEpoch uint64, slashed bool, epoch uint64) bool {
+func IsSlashableValidator(activationEpoch, withdrawableEpoch types.Epoch, slashed bool, epoch types.Epoch) bool {
 	return checkValidatorSlashable(activationEpoch, withdrawableEpoch, slashed, epoch)
 }
 
 // IsSlashableValidatorUsingTrie checks if a read only validator is slashable.
-func IsSlashableValidatorUsingTrie(val stateTrie.ReadOnlyValidator, epoch uint64) bool {
+func IsSlashableValidatorUsingTrie(val stateTrie.ReadOnlyValidator, epoch types.Epoch) bool {
 	return checkValidatorSlashable(val.ActivationEpoch(), val.WithdrawableEpoch(), val.Slashed(), epoch)
 }
 
-func checkValidatorSlashable(activationEpoch, withdrawableEpoch uint64, slashed bool, epoch uint64) bool {
+func checkValidatorSlashable(activationEpoch, withdrawableEpoch types.Epoch, slashed bool, epoch types.Epoch) bool {
 	active := activationEpoch <= epoch
 	beforeWithdrawable := epoch < withdrawableEpoch
 	return beforeWithdrawable && active && !slashed
@@ -72,7 +73,7 @@ func checkValidatorSlashable(activationEpoch, withdrawableEpoch uint64, slashed
 //    Return the sequence of active validator indices at ``epoch``.
 //    """
 //    return [ValidatorIndex(i) for i, v in enumerate(state.validators) if is_active_validator(v, epoch)]
-func ActiveValidatorIndices(state *stateTrie.BeaconState, epoch uint64) ([]uint64, error) {
+func ActiveValidatorIndices(state *stateTrie.BeaconState, epoch types.Epoch) ([]types.ValidatorIndex, error) {
 	seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get seed")
@@ -84,10 +85,10 @@ func ActiveValidatorIndices(state *stateTrie.BeaconState, epoch uint64) ([]uint6
 	if activeIndices != nil {
 		return activeIndices, nil
 	}
-	var indices []uint64
+	var indices []types.ValidatorIndex
 	if err := state.ReadFromEveryValidator(func(idx int, val stateTrie.ReadOnlyValidator) error {
 		if IsActiveValidatorUsingTrie(val, epoch) {
-			indices = append(indices, uint64(idx))
+			indices = append(indices, types.ValidatorIndex(idx))
 		}
 		return nil
 	}); err != nil {
@@ -103,7 +104,7 @@ func ActiveValidatorIndices(state *stateTrie.BeaconState, epoch uint64) ([]uint6
 
 // ActiveValidatorCount returns the number of active validators in the state
 // at the given epoch.
-func ActiveValidatorCount(state *stateTrie.BeaconState, epoch uint64) (uint64, error) {
+func ActiveValidatorCount(state *stateTrie.BeaconState, epoch types.Epoch) (uint64, error) {
 	seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	if err != nil {
 		return 0, errors.Wrap(err, "could not get seed")
@@ -142,7 +143,7 @@ func ActiveValidatorCount(state *stateTrie.BeaconState, epoch uint64) (uint64, e
 //    Return the epoch during which validator activations and exits initiated in ``epoch`` take effect.
 //    """
 //    return Epoch(epoch + 1 + MAX_SEED_LOOKAHEAD)
-func ActivationExitEpoch(epoch uint64) uint64 {
+func ActivationExitEpoch(epoch types.Epoch) types.Epoch {
 	return epoch + 1 + params.BeaconConfig().MaxSeedLookahead
 }
 
@@ -175,7 +176,7 @@ func ValidatorChurnLimit(activeValidatorCount uint64) (uint64, error) {
 //    seed = hash(get_seed(state, epoch, DOMAIN_BEACON_PROPOSER) + int_to_bytes(state.slot, length=8))
 //    indices = get_active_validator_indices(state, epoch)
 //    return compute_proposer_index(state, indices, seed)
-func BeaconProposerIndex(state *stateTrie.BeaconState) (uint64, error) {
+func BeaconProposerIndex(state *stateTrie.BeaconState) (types.ValidatorIndex, error) {
 	e := CurrentEpoch(state)
 	// The cache uses the state root of the previous epoch - minimum_seed_lookahead last slot as key. (e.g. Starting epoch 1, slot 32, the key would be block root at slot 31)
 	// For simplicity, the node will skip caching of genesis epoch.
@@ -203,7 +204,7 @@ func BeaconProposerIndex(state *stateTrie.BeaconState) (uint64, error) {
 				}
 				return proposerIndices[state.Slot()%params.BeaconConfig().SlotsPerEpoch], nil
 			}
-			if err := UpdateProposerIndicesInCache(state, e); err != nil {
+			if err := UpdateProposerIndicesInCache(state); err != nil {
 				return 0, errors.Wrap(err, "could not update committee cache")
 			}
 		}
@@ -214,7 +215,7 @@ func BeaconProposerIndex(state *stateTrie.BeaconState) (uint64, error) {
 		return 0, errors.Wrap(err, "could not generate seed")
 	}
 
-	seedWithSlot := append(seed[:], bytesutil.Bytes8(state.Slot())...)
+	seedWithSlot := append(seed[:], bytesutil.Bytes8(uint64(state.Slot()))...)
 	seedWithSlotHash := hashutil.Hash(seedWithSlot)
 
 	indices, err := ActiveValidatorIndices(state, e)
@@ -242,7 +243,7 @@ func BeaconProposerIndex(state *stateTrie.BeaconState) (uint64, error) {
 //        if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte:
 //            return ValidatorIndex(candidate_index)
 //        i += 1
-func ComputeProposerIndex(bState *stateTrie.BeaconState, activeIndices []uint64, seed [32]byte) (uint64, error) {
+func ComputeProposerIndex(bState *stateTrie.BeaconState, activeIndices []types.ValidatorIndex, seed [32]byte) (types.ValidatorIndex, error) {
 	length := uint64(len(activeIndices))
 	if length == 0 {
 		return 0, errors.New("empty active indices list")
@@ -251,12 +252,12 @@ func ComputeProposerIndex(bState *stateTrie.BeaconState, activeIndices []uint64,
 	hashFunc := hashutil.CustomSHA256Hasher()
 
 	for i := uint64(0); ; i++ {
-		candidateIndex, err := ComputeShuffledIndex(i%length, length, seed, true /* shuffle */)
+		candidateIndex, err := ComputeShuffledIndex(types.ValidatorIndex(i%length), length, seed, true /* shuffle */)
 		if err != nil {
 			return 0, err
 		}
 		candidateIndex = activeIndices[candidateIndex]
-		if candidateIndex >= uint64(bState.NumValidators()) {
+		if uint64(candidateIndex) >= uint64(bState.NumValidators()) {
 			return 0, errors.New("active index out of range")
 		}
 		b := append(seed[:], bytesutil.Bytes8(i/32)...)
@@ -283,7 +284,7 @@ func ComputeProposerIndex(bState *stateTrie.BeaconState, activeIndices []uint64,
 //    epoch = get_current_epoch(state) if epoch is None else epoch
 //    fork_version = state.fork.previous_version if epoch < state.fork.epoch else state.fork.current_version
 //    return compute_domain(domain_type, fork_version, state.genesis_validators_root)
-func Domain(fork *pb.Fork, epoch uint64, domainType [bls.DomainByteLength]byte, genesisRoot []byte) ([]byte, error) {
+func Domain(fork *pb.Fork, epoch types.Epoch, domainType [bls.DomainByteLength]byte, genesisRoot []byte) ([]byte, error) {
 	if fork == nil {
 		return []byte{}, errors.New("nil fork or domain type")
 	}
@@ -324,7 +325,7 @@ func IsEligibleForActivationQueueUsingTrie(validator stateTrie.ReadOnlyValidator
 }
 
 // isEligibleForActivationQueue carries out the logic for IsEligibleForActivationQueue*
-func isEligibileForActivationQueue(activationEligibilityEpoch, effectiveBalance uint64) bool {
+func isEligibileForActivationQueue(activationEligibilityEpoch types.Epoch, effectiveBalance uint64) bool {
 	return activationEligibilityEpoch == params.BeaconConfig().FarFutureEpoch &&
 		effectiveBalance == params.BeaconConfig().MaxEffectiveBalance
 }
@@ -357,7 +358,7 @@ func IsEligibleForActivationUsingTrie(state *stateTrie.BeaconState, validator st
 }
 
 // isEligibleForActivation carries out the logic for IsEligibleForActivation*
-func isEligibleForActivation(activationEligibilityEpoch, activationEpoch, finalizedEpoch uint64) bool {
+func isEligibleForActivation(activationEligibilityEpoch, activationEpoch, finalizedEpoch types.Epoch) bool {
 	return activationEligibilityEpoch <= finalizedEpoch &&
 		activationEpoch == params.BeaconConfig().FarFutureEpoch
 }

beacon-chain/core/helpers/validators_test.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -17,7 +18,7 @@ import (
 
 func TestIsActiveValidator_OK(t *testing.T) {
 	tests := []struct {
-		a uint64
+		a types.Epoch
 		b bool
 	}{
 		{a: 0, b: false},
@@ -34,7 +35,7 @@ func TestIsActiveValidator_OK(t *testing.T) {
 
 func TestIsActiveValidatorUsingTrie_OK(t *testing.T) {
 	tests := []struct {
-		a uint64
+		a types.Epoch
 		b bool
 	}{
 		{a: 0, b: false},
@@ -57,7 +58,7 @@ func TestIsSlashableValidator_OK(t *testing.T) {
 	tests := []struct {
 		name      string
 		validator *ethpb.Validator
-		epoch     uint64
+		epoch     types.Epoch
 		slashable bool
 	}{
 		{
@@ -139,7 +140,7 @@ func TestIsSlashableValidatorUsingTrie_OK(t *testing.T) {
 	tests := []struct {
 		name      string
 		validator *ethpb.Validator
-		epoch     uint64
+		epoch     types.Epoch
 		slashable bool
 	}{
 		{
@@ -241,8 +242,8 @@ func TestBeaconProposerIndex_OK(t *testing.T) {
 	require.NoError(t, err)
 
 	tests := []struct {
-		slot  uint64
-		index uint64
+		slot  types.Slot
+		index types.ValidatorIndex
 	}{
 		{
 			slot:  1,
@@ -288,7 +289,7 @@ func TestBeaconProposerIndex_BadState(t *testing.T) {
 		}
 	}
 	roots := make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot)
-	for i := uint64(0); i < params.BeaconConfig().SlotsPerHistoricalRoot; i++ {
+	for i := uint64(0); i < uint64(params.BeaconConfig().SlotsPerHistoricalRoot); i++ {
 		roots[i] = make([]byte, 32)
 	}
 
@@ -325,10 +326,10 @@ func TestComputeProposerIndex_Compatibility(t *testing.T) {
 	indices, err := ActiveValidatorIndices(state, 0)
 	require.NoError(t, err)
 
-	var proposerIndices []uint64
+	var proposerIndices []types.ValidatorIndex
 	seed, err := Seed(state, 0, params.BeaconConfig().DomainBeaconProposer)
 	require.NoError(t, err)
-	for i := uint64(0); i < params.BeaconConfig().SlotsPerEpoch; i++ {
+	for i := uint64(0); i < uint64(params.BeaconConfig().SlotsPerEpoch); i++ {
 		seedWithSlot := append(seed[:], bytesutil.Bytes8(i)...)
 		seedWithSlotHash := hashutil.Hash(seedWithSlot)
 		index, err := ComputeProposerIndex(state, indices, seedWithSlotHash)
@@ -336,10 +337,10 @@ func TestComputeProposerIndex_Compatibility(t *testing.T) {
 		proposerIndices = append(proposerIndices, index)
 	}
 
-	var wantedProposerIndices []uint64
+	var wantedProposerIndices []types.ValidatorIndex
 	seed, err = Seed(state, 0, params.BeaconConfig().DomainBeaconProposer)
 	require.NoError(t, err)
-	for i := uint64(0); i < params.BeaconConfig().SlotsPerEpoch; i++ {
+	for i := uint64(0); i < uint64(params.BeaconConfig().SlotsPerEpoch); i++ {
 		seedWithSlot := append(seed[:], bytesutil.Bytes8(i)...)
 		seedWithSlotHash := hashutil.Hash(seedWithSlot)
 		index, err := computeProposerIndexWithValidators(state.Validators(), indices, seedWithSlotHash)
@@ -350,7 +351,7 @@ func TestComputeProposerIndex_Compatibility(t *testing.T) {
 }
 
 func TestDelayedActivationExitEpoch_OK(t *testing.T) {
-	epoch := uint64(9999)
+	epoch := types.Epoch(9999)
 	wanted := epoch + 1 + params.BeaconConfig().MaxSeedLookahead
 	assert.Equal(t, wanted, ActivationExitEpoch(epoch))
 }
@@ -373,7 +374,7 @@ func TestActiveValidatorCount_Genesis(t *testing.T) {
 	// Preset cache to a bad count.
 	seed, err := Seed(beaconState, 0, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(t, err)
-	require.NoError(t, committeeCache.AddCommitteeShuffledList(&cache.Committees{Seed: seed, ShuffledIndices: []uint64{1, 2, 3}}))
+	require.NoError(t, committeeCache.AddCommitteeShuffledList(&cache.Committees{Seed: seed, ShuffledIndices: []types.ValidatorIndex{1, 2, 3}}))
 	validatorCount, err := ActiveValidatorCount(beaconState, CurrentEpoch(beaconState))
 	require.NoError(t, err)
 	assert.Equal(t, uint64(c), validatorCount, "Did not get the correct validator count")
@@ -422,7 +423,7 @@ func TestDomain_OK(t *testing.T) {
 		},
 	}
 	tests := []struct {
-		epoch      uint64
+		epoch      types.Epoch
 		domainType [4]byte
 		result     []byte
 	}{
@@ -445,12 +446,12 @@ func TestActiveValidatorIndices(t *testing.T) {
 	farFutureEpoch := params.BeaconConfig().FarFutureEpoch
 	type args struct {
 		state *pb.BeaconState
-		epoch uint64
+		epoch types.Epoch
 	}
 	tests := []struct {
 		name      string
 		args      args
-		want      []uint64
+		want      []types.ValidatorIndex
 		wantedErr string
 	}{
 		{
@@ -475,7 +476,7 @@ func TestActiveValidatorIndices(t *testing.T) {
 				},
 				epoch: 10,
 			},
-			want: []uint64{0, 1, 2},
+			want: []types.ValidatorIndex{0, 1, 2},
 		},
 		{
 			name: "some_active_epoch_10",
@@ -499,7 +500,7 @@ func TestActiveValidatorIndices(t *testing.T) {
 				},
 				epoch: 10,
 			},
-			want: []uint64{0, 1},
+			want: []types.ValidatorIndex{0, 1},
 		},
 		{
 			name: "some_active_with_recent_new_epoch_10",
@@ -527,7 +528,7 @@ func TestActiveValidatorIndices(t *testing.T) {
 				},
 				epoch: 10,
 			},
-			want: []uint64{0, 1, 3},
+			want: []types.ValidatorIndex{0, 1, 3},
 		},
 		{
 			name: "some_active_with_recent_new_epoch_10",
@@ -555,7 +556,7 @@ func TestActiveValidatorIndices(t *testing.T) {
 				},
 				epoch: 10,
 			},
-			want: []uint64{0, 1, 3},
+			want: []types.ValidatorIndex{0, 1, 3},
 		},
 		{
 			name: "some_active_with_recent_new_epoch_10",
@@ -583,7 +584,7 @@ func TestActiveValidatorIndices(t *testing.T) {
 				},
 				epoch: 10,
 			},
-			want: []uint64{0, 2, 3},
+			want: []types.ValidatorIndex{0, 2, 3},
 		},
 	}
 	for _, tt := range tests {
@@ -605,13 +606,13 @@ func TestComputeProposerIndex(t *testing.T) {
 	seed := bytesutil.ToBytes32([]byte("seed"))
 	type args struct {
 		validators []*ethpb.Validator
-		indices    []uint64
+		indices    []types.ValidatorIndex
 		seed       [32]byte
 	}
 	tests := []struct {
 		name      string
 		args      args
-		want      uint64
+		want      types.ValidatorIndex
 		wantedErr string
 	}{
 		{
@@ -624,7 +625,7 @@ func TestComputeProposerIndex(t *testing.T) {
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 				},
-				indices: []uint64{0, 1, 2, 3, 4},
+				indices: []types.ValidatorIndex{0, 1, 2, 3, 4},
 				seed:    seed,
 			},
 			want: 2,
@@ -639,7 +640,7 @@ func TestComputeProposerIndex(t *testing.T) {
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 				},
-				indices: []uint64{3},
+				indices: []types.ValidatorIndex{3},
 				seed:    seed,
 			},
 			want: 3,
@@ -654,7 +655,7 @@ func TestComputeProposerIndex(t *testing.T) {
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 				},
-				indices: []uint64{},
+				indices: []types.ValidatorIndex{},
 				seed:    seed,
 			},
 			wantedErr: "empty active indices list",
@@ -669,7 +670,7 @@ func TestComputeProposerIndex(t *testing.T) {
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 				},
-				indices: []uint64{100},
+				indices: []types.ValidatorIndex{100},
 				seed:    seed,
 			},
 			wantedErr: "active index out of range",
@@ -689,7 +690,7 @@ func TestComputeProposerIndex(t *testing.T) {
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 				},
-				indices: []uint64{5, 6, 7, 8, 9},
+				indices: []types.ValidatorIndex{5, 6, 7, 8, 9},
 				seed:    seed,
 			},
 			want: 7,
@@ -704,7 +705,7 @@ func TestComputeProposerIndex(t *testing.T) {
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
 				},
-				indices: []uint64{0, 1, 2, 3, 4},
+				indices: []types.ValidatorIndex{0, 1, 2, 3, 4},
 				seed:    seed,
 			},
 			want: 4,
@@ -777,7 +778,7 @@ func TestIsIsEligibleForActivation(t *testing.T) {
 	}
 }
 
-func computeProposerIndexWithValidators(validators []*ethpb.Validator, activeIndices []uint64, seed [32]byte) (uint64, error) {
+func computeProposerIndexWithValidators(validators []*ethpb.Validator, activeIndices []types.ValidatorIndex, seed [32]byte) (types.ValidatorIndex, error) {
 	length := uint64(len(activeIndices))
 	if length == 0 {
 		return 0, errors.New("empty active indices list")
@@ -786,12 +787,12 @@ func computeProposerIndexWithValidators(validators []*ethpb.Validator, activeInd
 	hashFunc := hashutil.CustomSHA256Hasher()
 
 	for i := uint64(0); ; i++ {
-		candidateIndex, err := ComputeShuffledIndex(i%length, length, seed, true /* shuffle */)
+		candidateIndex, err := ComputeShuffledIndex(types.ValidatorIndex(i%length), length, seed, true /* shuffle */)
 		if err != nil {
 			return 0, err
 		}
 		candidateIndex = activeIndices[candidateIndex]
-		if candidateIndex >= uint64(len(validators)) {
+		if uint64(candidateIndex) >= uint64(len(validators)) {
 			return 0, errors.New("active index out of range")
 		}
 		b := append(seed[:], bytesutil.Bytes8(i/32)...)

beacon-chain/core/state/BUILD.bazel

@@ -44,6 +44,7 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
@@ -79,13 +80,13 @@ go_test(
         "//shared/bytesutil:go_default_library",
         "//shared/hashutil:go_default_library",
         "//shared/params:go_default_library",
-        "//shared/sszutil:go_default_library",
         "//shared/testutil:go_default_library",
         "//shared/testutil/assert:go_default_library",
         "//shared/testutil/require:go_default_library",
         "//shared/trieutil:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",

beacon-chain/core/state/skip_slot_cache.go

@@ -2,6 +2,7 @@ package state
 
 import (
 	"context"
+	"errors"
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -19,9 +20,13 @@ var SkipSlotCache = cache.NewSkipSlotCache()
 // state root is in the mix to defend against different forks with same skip slots
 // to hit the same cache. We don't want beacon states mixed up between different chains.
 func cacheKey(ctx context.Context, state *beaconstate.BeaconState) ([32]byte, error) {
-	r, err := state.HashTreeRoot(ctx)
+	bh := state.LatestBlockHeader()
+	if bh == nil {
+		return [32]byte{}, errors.New("block head in state can't be nil")
+	}
+	r, err := bh.HashTreeRoot()
 	if err != nil {
 		return [32]byte{}, err
 	}
-	return hashutil.Hash(append(bytesutil.Bytes32(state.Slot()), r[:]...)), nil
+	return hashutil.Hash(append(bytesutil.Bytes32(uint64(state.Slot())), r[:]...)), nil
 }

beacon-chain/core/state/skip_slot_cache_test.go

@@ -8,7 +8,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/sszutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
@@ -34,9 +33,7 @@ func TestSkipSlotCache_OK(t *testing.T) {
 	bState, err = state.ExecuteStateTransition(context.Background(), bState, blk)
 	require.NoError(t, err, "Could not process state transition")
 
-	if !sszutil.DeepEqual(originalState.CloneInnerState(), bState.CloneInnerState()) {
-		t.Fatal("Skipped slots cache leads to different states")
-	}
+	assert.DeepEqual(t, originalState.CloneInnerState(), bState.CloneInnerState(), "Skipped slots cache leads to different states")
 }
 
 func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
@@ -132,7 +129,7 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
 
 	step := func(i int, setup *beaconstate.BeaconState) {
 		// go at least 1 past problemSlot, to ensure problem slot state root is available
-		outState, err := state.ProcessSlots(context.Background(), setup, problemSlot+1+uint64(i)) // keep increasing, to hit and extend the cache
+		outState, err := state.ProcessSlots(context.Background(), setup, problemSlot.Add(1+uint64(i))) // keep increasing, to hit and extend the cache
 		require.NoError(t, err, "Could not process state transition")
 		roots := outState.StateRoots()
 		gotRoot := roots[problemSlot]

beacon-chain/core/state/spectest/slot_processing_test.go

@@ -43,7 +43,7 @@ func runSlotProcessingTests(t *testing.T, config string) {
 			require.NoError(t, err)
 			postBeaconState := &pb.BeaconState{}
 			require.NoError(t, postBeaconState.UnmarshalSSZ(postBeaconStateFile), "Failed to unmarshal")
-			postState, err := state.ProcessSlots(context.Background(), beaconState, beaconState.Slot()+uint64(slotsCount))
+			postState, err := state.ProcessSlots(context.Background(), beaconState, beaconState.Slot().Add(uint64(slotsCount)))
 			require.NoError(t, err)
 
 			if !proto.Equal(postState.CloneInnerState(), postBeaconState) {

beacon-chain/core/state/state_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -15,19 +16,19 @@ import (
 )
 
 func TestGenesisBeaconState_OK(t *testing.T) {
-	genesisEpochNumber := uint64(0)
+	genesisEpoch := types.Epoch(0)
 
 	assert.DeepEqual(t, []byte{0, 0, 0, 0}, params.BeaconConfig().GenesisForkVersion, "GenesisSlot( should be {0,0,0,0} for these tests to pass")
 	genesisForkVersion := params.BeaconConfig().GenesisForkVersion
 
 	assert.Equal(t, [32]byte{}, params.BeaconConfig().ZeroHash, "ZeroHash should be all 0s for these tests to pass")
-	assert.Equal(t, uint64(65536), params.BeaconConfig().EpochsPerHistoricalVector, "EpochsPerHistoricalVector should be 8192 for these tests to pass")
+	assert.Equal(t, types.Epoch(65536), params.BeaconConfig().EpochsPerHistoricalVector, "EpochsPerHistoricalVector should be 8192 for these tests to pass")
 
 	latestRandaoMixesLength := params.BeaconConfig().EpochsPerHistoricalVector
 	assert.Equal(t, uint64(16777216), params.BeaconConfig().HistoricalRootsLimit, "HistoricalRootsLimit should be 16777216 for these tests to pass")
 
 	depositsForChainStart := 100
-	assert.Equal(t, uint64(8192), params.BeaconConfig().EpochsPerSlashingsVector, "EpochsPerSlashingsVector should be 8192 for these tests to pass")
+	assert.Equal(t, types.Epoch(8192), params.BeaconConfig().EpochsPerSlashingsVector, "EpochsPerSlashingsVector should be 8192 for these tests to pass")
 
 	genesisTime := uint64(99999)
 	deposits, _, err := testutil.DeterministicDepositsAndKeys(uint64(depositsForChainStart))
@@ -38,11 +39,11 @@ func TestGenesisBeaconState_OK(t *testing.T) {
 	require.NoError(t, err, "Could not execute GenesisBeaconState")
 
 	// Misc fields checks.
-	assert.Equal(t, uint64(0), newState.Slot(), "Slot was not correctly initialized")
+	assert.Equal(t, types.Slot(0), newState.Slot(), "Slot was not correctly initialized")
 	if !proto.Equal(newState.Fork(), &pb.Fork{
 		PreviousVersion: genesisForkVersion,
 		CurrentVersion:  genesisForkVersion,
-		Epoch:           genesisEpochNumber,
+		Epoch:           genesisEpoch,
 	}) {
 		t.Error("Fork was not correctly initialized")
 	}
@@ -51,28 +52,28 @@ func TestGenesisBeaconState_OK(t *testing.T) {
 	assert.Equal(t, depositsForChainStart, len(newState.Validators()), "Validators was not correctly initialized")
 	v, err := newState.ValidatorAtIndex(0)
 	require.NoError(t, err)
-	assert.Equal(t, uint64(0), v.ActivationEpoch, "Validators was not correctly initialized")
+	assert.Equal(t, types.Epoch(0), v.ActivationEpoch, "Validators was not correctly initialized")
 	v, err = newState.ValidatorAtIndex(0)
 	require.NoError(t, err)
-	assert.Equal(t, uint64(0), v.ActivationEligibilityEpoch, "Validators was not correctly initialized")
+	assert.Equal(t, types.Epoch(0), v.ActivationEligibilityEpoch, "Validators was not correctly initialized")
 	assert.Equal(t, depositsForChainStart, len(newState.Balances()), "Balances was not correctly initialized")
 
 	// Randomness and committees fields checks.
-	assert.Equal(t, latestRandaoMixesLength, uint64(len(newState.RandaoMixes())), "Length of RandaoMixes was not correctly initialized")
+	assert.Equal(t, latestRandaoMixesLength, types.Epoch(len(newState.RandaoMixes())), "Length of RandaoMixes was not correctly initialized")
 	mix, err := newState.RandaoMixAtIndex(0)
 	require.NoError(t, err)
 	assert.DeepEqual(t, eth1Data.BlockHash, mix, "RandaoMixes was not correctly initialized")
 
 	// Finality fields checks.
-	assert.Equal(t, genesisEpochNumber, newState.PreviousJustifiedCheckpoint().Epoch, "PreviousJustifiedCheckpoint.Epoch was not correctly initialized")
-	assert.Equal(t, genesisEpochNumber, newState.CurrentJustifiedCheckpoint().Epoch, "JustifiedEpoch was not correctly initialized")
-	assert.Equal(t, genesisEpochNumber, newState.FinalizedCheckpointEpoch(), "FinalizedSlot was not correctly initialized")
+	assert.Equal(t, genesisEpoch, newState.PreviousJustifiedCheckpoint().Epoch, "PreviousJustifiedCheckpoint.Epoch was not correctly initialized")
+	assert.Equal(t, genesisEpoch, newState.CurrentJustifiedCheckpoint().Epoch, "JustifiedEpoch was not correctly initialized")
+	assert.Equal(t, genesisEpoch, newState.FinalizedCheckpointEpoch(), "FinalizedSlot was not correctly initialized")
 	assert.Equal(t, uint8(0x00), newState.JustificationBits()[0], "JustificationBits was not correctly initialized")
 
 	// Recent state checks.
 	assert.DeepEqual(t, make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector), newState.Slashings(), "Slashings was not correctly initialized")
-	assert.DeepEqual(t, []*pb.PendingAttestation{}, newState.CurrentEpochAttestations(), "CurrentEpochAttestations was not correctly initialized")
-	assert.DeepEqual(t, []*pb.PendingAttestation{}, newState.PreviousEpochAttestations(), "PreviousEpochAttestations was not correctly initialized")
+	assert.DeepSSZEqual(t, []*pb.PendingAttestation{}, newState.CurrentEpochAttestations(), "CurrentEpochAttestations was not correctly initialized")
+	assert.DeepSSZEqual(t, []*pb.PendingAttestation{}, newState.PreviousEpochAttestations(), "PreviousEpochAttestations was not correctly initialized")
 
 	zeroHash := params.BeaconConfig().ZeroHash[:]
 	// History root checks.
@@ -81,7 +82,7 @@ func TestGenesisBeaconState_OK(t *testing.T) {
 
 	// Deposit root checks.
 	assert.DeepEqual(t, eth1Data.DepositRoot, newState.Eth1Data().DepositRoot, "Eth1Data DepositRoot was not correctly initialized")
-	assert.DeepEqual(t, []*ethpb.Eth1Data{}, newState.Eth1DataVotes(), "Eth1DataVotes was not correctly initialized")
+	assert.DeepSSZEqual(t, []*ethpb.Eth1Data{}, newState.Eth1DataVotes(), "Eth1DataVotes was not correctly initialized")
 }
 
 func TestGenesisState_HashEquality(t *testing.T) {
@@ -104,7 +105,7 @@ func TestGenesisState_HashEquality(t *testing.T) {
 func TestGenesisState_InitializesLatestBlockHashes(t *testing.T) {
 	s, err := state.GenesisBeaconState(nil, 0, &ethpb.Eth1Data{})
 	require.NoError(t, err)
-	got, want := uint64(len(s.BlockRoots())), params.BeaconConfig().SlotsPerHistoricalRoot
+	got, want := uint64(len(s.BlockRoots())), uint64(params.BeaconConfig().SlotsPerHistoricalRoot)
 	assert.Equal(t, want, got, "Wrong number of recent block hashes")
 
 	got = uint64(cap(s.BlockRoots()))

beacon-chain/core/state/stateutils/BUILD.bazel

@@ -11,6 +11,7 @@ go_library(
     ],
     deps = [
         "//shared/bytesutil:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
     ],
 )
@@ -19,13 +20,14 @@ go_test(
     name = "go_default_test",
     size = "small",
     srcs = ["validator_index_map_test.go"],
+    embed = [":go_default_library"],
     deps = [
-        ":go_default_library",
         "//beacon-chain/state:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/bytesutil:go_default_library",
         "//shared/testutil/assert:go_default_library",
         "//shared/testutil/require:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
     ],
 )

beacon-chain/core/state/stateutils/validator_index_map.go

@@ -4,14 +4,15 @@
 package stateutils
 
 import (
+	types "github.com/prysmaticlabs/eth2-types"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 )
 
 // ValidatorIndexMap builds a lookup map for quickly determining the index of
 // a validator by their public key.
-func ValidatorIndexMap(validators []*ethpb.Validator) map[[48]byte]uint64 {
-	m := make(map[[48]byte]uint64, len(validators))
+func ValidatorIndexMap(validators []*ethpb.Validator) map[[48]byte]types.ValidatorIndex {
+	m := make(map[[48]byte]types.ValidatorIndex, len(validators))
 	if validators == nil {
 		return m
 	}
@@ -20,7 +21,7 @@ func ValidatorIndexMap(validators []*ethpb.Validator) map[[48]byte]uint64 {
 			continue
 		}
 		key := bytesutil.ToBytes48(record.PublicKey)
-		m[key] = uint64(idx)
+		m[key] = types.ValidatorIndex(idx)
 	}
 	return m
 }