add in interfaces

* Remove feature and flag Pyrmont testnet

* Remove unused parameter

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

BUILD.bazel

@@ -115,18 +115,19 @@ nogo(
         "@org_golang_x_tools//go/analysis/passes/assign:go_default_library",
         "@org_golang_x_tools//go/analysis/passes/inspect:go_default_library",
         "@org_golang_x_tools//go/analysis/passes/asmdecl:go_default_library",
-        "//tools/analyzers/maligned:go_default_library",
+        "//tools/analyzers/comparesame:go_default_library",
         "//tools/analyzers/cryptorand:go_default_library",
         "//tools/analyzers/errcheck:go_default_library",
         "//tools/analyzers/featureconfig:go_default_library",
-        "//tools/analyzers/comparesame:go_default_library",
-        "//tools/analyzers/shadowpredecl:go_default_library",
-        "//tools/analyzers/nop:go_default_library",
-        "//tools/analyzers/slicedirect:go_default_library",
-        "//tools/analyzers/interfacechecker:go_default_library",
+        "//tools/analyzers/gocognit:go_default_library",
         "//tools/analyzers/ineffassign:go_default_library",
+        "//tools/analyzers/interfacechecker:go_default_library",
+        "//tools/analyzers/maligned:go_default_library",
+        "//tools/analyzers/nop:go_default_library",
         "//tools/analyzers/properpermissions:go_default_library",
         "//tools/analyzers/recursivelock:go_default_library",
+        "//tools/analyzers/shadowpredecl:go_default_library",
+        "//tools/analyzers/slicedirect:go_default_library",
         "//tools/analyzers/uintcast:go_default_library",
     ] + select({
         # nogo checks that fail with coverage enabled.

beacon-chain/blockchain/process_block_helpers.go

@@ -407,6 +407,10 @@ func (s *Service) insertFinalizedDeposits(ctx context.Context, fRoot [32]byte) e
 	if err != nil {
 		return errors.Wrap(err, "could not cast eth1 deposit index")
 	}
+	// The deposit index in the state is always the index of the next deposit
+	// to be included(rather than the last one to be processed). This was most likely
+	// done as the state cannot represent signed integers.
+	eth1DepositIndex -= 1
 	s.cfg.DepositCache.InsertFinalizedDeposits(ctx, int64(eth1DepositIndex))
 	// Deposit proofs are only used during state transition and can be safely removed to save space.
 	if err = s.cfg.DepositCache.PruneProofs(ctx, int64(eth1DepositIndex)); err != nil {

beacon-chain/blockchain/process_block_test.go

@@ -1516,7 +1516,7 @@ func TestInsertFinalizedDeposits(t *testing.T) {
 	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	gs = gs.Copy()
 	assert.NoError(t, gs.SetEth1Data(&ethpb.Eth1Data{DepositCount: 10}))
-	assert.NoError(t, gs.SetEth1DepositIndex(7))
+	assert.NoError(t, gs.SetEth1DepositIndex(8))
 	assert.NoError(t, service.cfg.StateGen.SaveState(ctx, [32]byte{'m', 'o', 'c', 'k'}, gs))
 	zeroSig := [96]byte{}
 	for i := uint64(0); i < uint64(4*params.BeaconConfig().SlotsPerEpoch); i++ {
@@ -1555,11 +1555,11 @@ func TestInsertFinalizedDeposits_MultipleFinalizedRoutines(t *testing.T) {
 	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	gs = gs.Copy()
 	assert.NoError(t, gs.SetEth1Data(&ethpb.Eth1Data{DepositCount: 7}))
-	assert.NoError(t, gs.SetEth1DepositIndex(5))
+	assert.NoError(t, gs.SetEth1DepositIndex(6))
 	assert.NoError(t, service.cfg.StateGen.SaveState(ctx, [32]byte{'m', 'o', 'c', 'k'}, gs))
 	gs2 := gs.Copy()
 	assert.NoError(t, gs2.SetEth1Data(&ethpb.Eth1Data{DepositCount: 15}))
-	assert.NoError(t, gs2.SetEth1DepositIndex(12))
+	assert.NoError(t, gs2.SetEth1DepositIndex(13))
 	assert.NoError(t, service.cfg.StateGen.SaveState(ctx, [32]byte{'m', 'o', 'c', 'k', '2'}, gs2))
 	zeroSig := [96]byte{}
 	for i := uint64(0); i < uint64(4*params.BeaconConfig().SlotsPerEpoch); i++ {

beacon-chain/cache/depositcache/deposits_cache_test.go

@@ -749,6 +749,85 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
 	assert.Equal(t, 1, len(deps))
 }
 
+func TestFinalizedDeposits_ReturnsTrieCorrectly(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	generateCtr := func(height uint64, index int64) *ethpb.DepositContainer {
+		return &ethpb.DepositContainer{
+			Eth1BlockHeight: height,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{uint8(index)}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: index,
+		}
+	}
+
+	finalizedDeposits := []*ethpb.DepositContainer{
+		generateCtr(10, 0),
+		generateCtr(11, 1),
+		generateCtr(12, 2),
+		generateCtr(12, 3),
+		generateCtr(13, 4),
+		generateCtr(13, 5),
+		generateCtr(13, 6),
+		generateCtr(14, 7),
+	}
+	dc.deposits = append(finalizedDeposits,
+		generateCtr(15, 8),
+		generateCtr(15, 9),
+		generateCtr(30, 10))
+	trieItems := make([][]byte, 0, len(dc.deposits))
+	for _, dep := range dc.allDeposits(big.NewInt(30)) {
+		depHash, err := dep.Data.HashTreeRoot()
+		assert.NoError(t, err)
+		trieItems = append(trieItems, depHash[:])
+	}
+	depositTrie, err := trie.GenerateTrieFromItems(trieItems, params.BeaconConfig().DepositContractTreeDepth)
+	assert.NoError(t, err)
+
+	// Perform this in a non-sensical ordering
+	dc.InsertFinalizedDeposits(context.Background(), 10)
+	dc.InsertFinalizedDeposits(context.Background(), 2)
+	dc.InsertFinalizedDeposits(context.Background(), 3)
+	dc.InsertFinalizedDeposits(context.Background(), 4)
+
+	// Mimick finalized deposit trie fetch.
+	fd := dc.FinalizedDeposits(context.Background())
+	deps := dc.NonFinalizedDeposits(context.Background(), fd.MerkleTrieIndex, big.NewInt(14))
+	insertIndex := fd.MerkleTrieIndex + 1
+
+	for _, dep := range deps {
+		depHash, err := dep.Data.HashTreeRoot()
+		assert.NoError(t, err)
+		if err = fd.Deposits.Insert(depHash[:], int(insertIndex)); err != nil {
+			assert.NoError(t, err)
+		}
+		insertIndex++
+	}
+	dc.InsertFinalizedDeposits(context.Background(), 15)
+	dc.InsertFinalizedDeposits(context.Background(), 15)
+	dc.InsertFinalizedDeposits(context.Background(), 14)
+
+	fd = dc.FinalizedDeposits(context.Background())
+	deps = dc.NonFinalizedDeposits(context.Background(), fd.MerkleTrieIndex, big.NewInt(30))
+	insertIndex = fd.MerkleTrieIndex + 1
+
+	for _, dep := range deps {
+		depHash, err := dep.Data.HashTreeRoot()
+		assert.NoError(t, err)
+		if err = fd.Deposits.Insert(depHash[:], int(insertIndex)); err != nil {
+			assert.NoError(t, err)
+		}
+		insertIndex++
+	}
+	assert.Equal(t, fd.Deposits.NumOfItems(), depositTrie.NumOfItems())
+}
+
 func TestPruneProofs_Ok(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)

beacon-chain/core/altair/epoch_precompute.go

@@ -270,6 +270,7 @@ func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, v
 	// Modified in Altair and Bellatrix.
 	var inactivityDenominator uint64
 	bias := cfg.InactivityScoreBias
+	inactivityDenominator := bias * beaconState.InactivityPenaltyQuotient()
 	switch beaconState.Version() {
 	case version.Altair:
 		inactivityDenominator = bias * cfg.InactivityPenaltyQuotientAltair

beacon-chain/powchain/check_transition_config.go

@@ -120,11 +120,16 @@ func (s *Service) handleExchangeConfigurationError(err error) {
 // Logs the terminal total difficulty status.
 func (s *Service) logTtdStatus(ctx context.Context, ttd *uint256.Int) (bool, error) {
 	latest, err := s.LatestExecutionBlock(ctx)
-	if err != nil {
+	switch {
+	case errors.Is(err, hexutil.ErrEmptyString):
+		return false, nil
+	case err != nil:
 		return false, err
-	}
-	if latest == nil {
+	case latest == nil:
 		return false, errors.New("latest block is nil")
+	case latest.TotalDifficulty == "":
+		return false, nil
+	default:
 	}
 	latestTtd, err := hexutil.DecodeBig(latest.TotalDifficulty)
 	if err != nil {

beacon-chain/powchain/check_transition_config_test.go

@@ -190,6 +190,38 @@ func TestService_logTtdStatus(t *testing.T) {
 	require.Equal(t, false, reached)
 }
 
+func TestService_logTtdStatus_NotSyncedClient(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		defer func() {
+			require.NoError(t, r.Body.Close())
+		}()
+
+		resp := (*pb.ExecutionBlock)(nil) // Nil response when a client is not synced
+		respJSON := map[string]interface{}{
+			"jsonrpc": "2.0",
+			"id":      1,
+			"result":  resp,
+		}
+		require.NoError(t, json.NewEncoder(w).Encode(respJSON))
+	}))
+	defer srv.Close()
+
+	rpcClient, err := rpc.DialHTTP(srv.URL)
+	require.NoError(t, err)
+	defer rpcClient.Close()
+
+	service := &Service{
+		cfg: &config{},
+	}
+	service.rpcClient = rpcClient
+
+	ttd := new(uint256.Int)
+	reached, err := service.logTtdStatus(context.Background(), ttd.SetUint64(24343))
+	require.NoError(t, err)
+	require.Equal(t, false, reached)
+}
+
 func emptyPayload() *pb.ExecutionPayload {
 	return &pb.ExecutionPayload{
 		ParentHash:    make([]byte, fieldparams.RootLength),

beacon-chain/powchain/service.go

@@ -413,11 +413,14 @@ func (s *Service) initDepositCaches(ctx context.Context, ctrs []*ethpb.DepositCo
 		// accumulates. we finalize them here before we are ready to receive a block.
 		// Otherwise, the first few blocks will be slower to compute as we will
 		// hold the lock and be busy finalizing the deposits.
-		s.cfg.depositCache.InsertFinalizedDeposits(ctx, int64(currIndex)) // lint:ignore uintcast -- deposit index will not exceed int64 in your lifetime.
+		// The deposit index in the state is always the index of the next deposit
+		// to be included(rather than the last one to be processed). This was most likely
+		// done as the state cannot represent signed integers.
+		actualIndex := int64(currIndex) - 1 // lint:ignore uintcast -- deposit index will not exceed int64 in your lifetime.
+		s.cfg.depositCache.InsertFinalizedDeposits(ctx, actualIndex)
 		// Deposit proofs are only used during state transition and can be safely removed to save space.
 
-		// lint:ignore uintcast -- deposit index will not exceed int64 in your lifetime.
-		if err = s.cfg.depositCache.PruneProofs(ctx, int64(currIndex)); err != nil {
+		if err = s.cfg.depositCache.PruneProofs(ctx, actualIndex); err != nil {
 			return errors.Wrap(err, "could not prune deposit proofs")
 		}
 	}

beacon-chain/powchain/service_test.go

@@ -472,7 +472,7 @@ func TestInitDepositCacheWithFinalization_OK(t *testing.T) {
 	require.NoError(t, s.cfg.beaconDB.SaveState(context.Background(), emptyState, headRoot))
 	require.NoError(t, stateGen.SaveState(context.Background(), headRoot, emptyState))
 	s.cfg.stateGen = stateGen
-	require.NoError(t, emptyState.SetEth1DepositIndex(2))
+	require.NoError(t, emptyState.SetEth1DepositIndex(3))
 
 	ctx := context.Background()
 	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(0), Root: headRoot[:]}))

beacon-chain/state/phase0.go

@@ -16,12 +16,19 @@ import (
 type BeaconState interface {
 	ReadOnlyBeaconState
 	WriteOnlyBeaconState
+	SpecConstantsProvider
 	Copy() BeaconState
 	HashTreeRoot(ctx context.Context) ([32]byte, error)
 	FutureForkStub
 	StateProver
 }
 
+// SpecConstantsProvider defines a struct which can provide varying configuration
+// values depending on fork versions, such as the beacon state.
+type SpecConstantsProvider interface {
+	InactivityPenaltyQuotient() (uint64, error)
+}
+
 // StateProver defines the ability to create Merkle proofs for beacon state fields.
 type StateProver interface {
 	FinalizedRootProof(ctx context.Context) ([][]byte, error)

beacon-chain/state/state-native/v1/spec_constants.go

@@ -0,0 +1,7 @@
+package v1
+
+import "github.com/prysmaticlabs/prysm/config/params"
+
+func (b *BeaconState) InactivityPenaltyQuotient() uint64 {
+	return params.BeaconConfig().InactivityPenaltyQuotient
+}

beacon-chain/state/state-native/v2/spec_constants.go

@@ -0,0 +1,7 @@
+package v2
+
+import "github.com/prysmaticlabs/prysm/config/params"
+
+func (b *BeaconState) InactivityPenaltyQuotient() uint64 {
+	return params.BeaconConfig().InactivityPenaltyQuotientAltair
+}

beacon-chain/state/state-native/v3/spec_constants.go

@@ -0,0 +1,7 @@
+package v3
+
+import "github.com/prysmaticlabs/prysm/config/params"
+
+func (b *BeaconState) InactivityPenaltyQuotient() uint64 {
+	return params.BeaconConfig().InactivityPenaltyQuotientBellatrix
+}

beacon-chain/state/v1/spec_constants.go

@@ -0,0 +1,7 @@
+package v1
+
+import "github.com/prysmaticlabs/prysm/config/params"
+
+func (b *BeaconState) InactivityPenaltyQuotient() uint64 {
+	return params.BeaconConfig().InactivityPenaltyQuotient
+}

beacon-chain/state/v2/spec_constants.go

@@ -0,0 +1,7 @@
+package v1
+
+import "github.com/prysmaticlabs/prysm/config/params"
+
+func (b *BeaconState) InactivityPenaltyQuotient() uint64 {
+	return params.BeaconConfig().InactivityPenaltyQuotientAltair
+}

beacon-chain/state/v3/spec_constants.go

@@ -0,0 +1,7 @@
+package v1
+
+import "github.com/prysmaticlabs/prysm/config/params"
+
+func (b *BeaconState) InactivityPenaltyQuotient() uint64 {
+	return params.BeaconConfig().InactivityPenaltyQuotientBellatrix
+}

beacon-chain/sync/initial-sync/service.go

@@ -49,30 +49,29 @@ type Service struct {
 	synced       *abool.AtomicBool
 	chainStarted *abool.AtomicBool
 	counter      *ratecounter.RateCounter
-	genesisChan  chan time.Time
 }
 
 // NewService configures the initial sync service responsible for bringing the node up to the
 // latest head of the blockchain.
 func NewService(ctx context.Context, cfg *Config) *Service {
 	ctx, cancel := context.WithCancel(ctx)
-	s := &Service{
+	return &Service{
 		cfg:          cfg,
 		ctx:          ctx,
 		cancel:       cancel,
 		synced:       abool.New(),
 		chainStarted: abool.New(),
 		counter:      ratecounter.NewRateCounter(counterSeconds * time.Second),
-		genesisChan:  make(chan time.Time),
 	}
-	go s.waitForStateInitialization()
-	return s
 }
 
 // Start the initial sync service.
 func (s *Service) Start() {
-	// Wait for state initialized event.
-	genesis := <-s.genesisChan
+	genesis, err := s.waitForStateInitialization()
+	if err != nil {
+		log.WithError(err).Fatal("Failed to wait for state initialization.")
+		return
+	}
 	if genesis.IsZero() {
 		log.Debug("Exiting Initial Sync Service")
 		return
@@ -180,9 +179,10 @@ func (s *Service) waitForMinimumPeers() {
 	}
 }
 
+// TODO: Return error
 // waitForStateInitialization makes sure that beacon node is ready to be accessed: it is either
 // already properly configured or system waits up until state initialized event is triggered.
-func (s *Service) waitForStateInitialization() {
+func (s *Service) waitForStateInitialization() (time.Time, error) {
 	// Wait for state to be initialized.
 	stateChannel := make(chan *feed.Event, 1)
 	stateSub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
@@ -198,19 +198,14 @@ func (s *Service) waitForStateInitialization() {
 					continue
 				}
 				log.WithField("starttime", data.StartTime).Debug("Received state initialized event")
-				s.genesisChan <- data.StartTime
-				return
+				return data.StartTime, nil
 			}
 		case <-s.ctx.Done():
-			log.Debug("Context closed, exiting goroutine")
 			// Send a zero time in the event we are exiting.
-			s.genesisChan <- time.Time{}
-			return
+			return time.Time{}, errors.New("context closed, exiting goroutine")
 		case err := <-stateSub.Err():
-			log.WithError(err).Error("Subscription to state notifier failed")
 			// Send a zero time in the event we are exiting.
-			s.genesisChan <- time.Time{}
-			return
+			return time.Time{}, errors.Wrap(err, "subscription to state notifier failed")
 		}
 	}
 }

beacon-chain/sync/initial-sync/service_test.go

@@ -168,11 +168,7 @@ func TestService_InitStartStop(t *testing.T) {
 				Chain:         mc,
 				StateNotifier: notifier,
 			})
-			time.Sleep(500 * time.Millisecond)
 			assert.NotNil(t, s)
-			if tt.methodRuns != nil {
-				tt.methodRuns(notifier.StateFeed())
-			}
 
 			wg := &sync.WaitGroup{}
 			wg.Add(1)
@@ -181,6 +177,11 @@ func TestService_InitStartStop(t *testing.T) {
 				wg.Done()
 			}()
 
+			time.Sleep(500 * time.Millisecond)
+			if tt.methodRuns != nil {
+				tt.methodRuns(notifier.StateFeed())
+			}
+
 			go func() {
 				// Allow to exit from test (on no head loop waiting for head is started).
 				// In most tests, this is redundant, as Start() already exited.
@@ -207,7 +208,6 @@ func TestService_waitForStateInitialization(t *testing.T) {
 			synced:       abool.New(),
 			chainStarted: abool.New(),
 			counter:      ratecounter.NewRateCounter(counterSeconds * time.Second),
-			genesisChan:  make(chan time.Time),
 		}
 		return s
 	}
@@ -221,9 +221,8 @@ func TestService_waitForStateInitialization(t *testing.T) {
 		wg := &sync.WaitGroup{}
 		wg.Add(1)
 		go func() {
-			go s.waitForStateInitialization()
-			currTime := <-s.genesisChan
-			assert.Equal(t, true, currTime.IsZero())
+			_, err := s.waitForStateInitialization()
+			assert.ErrorContains(t, "context closed", err)
 			wg.Done()
 		}()
 		go func() {
@@ -236,8 +235,6 @@ func TestService_waitForStateInitialization(t *testing.T) {
 			t.Fatalf("Test should have exited by now, timed out")
 		}
 		assert.LogsContain(t, hook, "Waiting for state to be initialized")
-		assert.LogsContain(t, hook, "Context closed, exiting goroutine")
-		assert.LogsDoNotContain(t, hook, "Subscription to state notifier failed")
 	})
 
 	t.Run("no state and state init event received", func(t *testing.T) {
@@ -251,8 +248,9 @@ func TestService_waitForStateInitialization(t *testing.T) {
 		wg := &sync.WaitGroup{}
 		wg.Add(1)
 		go func() {
-			go s.waitForStateInitialization()
-			receivedGenesisTime = <-s.genesisChan
+			var err error
+			receivedGenesisTime, err = s.waitForStateInitialization()
+			require.NoError(t, err)
 			assert.Equal(t, false, receivedGenesisTime.IsZero())
 			wg.Done()
 		}()
@@ -281,7 +279,6 @@ func TestService_waitForStateInitialization(t *testing.T) {
 		assert.LogsContain(t, hook, "Event feed data is not type *statefeed.InitializedData")
 		assert.LogsContain(t, hook, "Waiting for state to be initialized")
 		assert.LogsContain(t, hook, "Received state initialized event")
-		assert.LogsDoNotContain(t, hook, "Context closed, exiting goroutine")
 	})
 
 	t.Run("no state and state init event received and service start", func(t *testing.T) {
@@ -296,7 +293,8 @@ func TestService_waitForStateInitialization(t *testing.T) {
 		wg := &sync.WaitGroup{}
 		wg.Add(1)
 		go func() {
-			s.waitForStateInitialization()
+			_, err := s.waitForStateInitialization()
+			require.NoError(t, err)
 			wg.Done()
 		}()
 
@@ -321,7 +319,6 @@ func TestService_waitForStateInitialization(t *testing.T) {
 		}
 		assert.LogsContain(t, hook, "Waiting for state to be initialized")
 		assert.LogsContain(t, hook, "Received state initialized event")
-		assert.LogsDoNotContain(t, hook, "Context closed, exiting goroutine")
 	})
 }
 

cmd/validator/accounts/accounts.go

@@ -28,7 +28,6 @@ var Commands = &cli.Command{
 				flags.WalletPasswordFileFlag,
 				flags.DeletePublicKeysFlag,
 				features.Mainnet,
-				features.PyrmontTestnet,
 				features.PraterTestnet,
 				cmd.AcceptTosFlag,
 			}),
@@ -62,7 +61,6 @@ var Commands = &cli.Command{
 				flags.GrpcRetriesFlag,
 				flags.GrpcRetryDelayFlag,
 				features.Mainnet,
-				features.PyrmontTestnet,
 				features.PraterTestnet,
 				cmd.AcceptTosFlag,
 			}),
@@ -93,7 +91,6 @@ var Commands = &cli.Command{
 				flags.BackupPublicKeysFlag,
 				flags.BackupPasswordFile,
 				features.Mainnet,
-				features.PyrmontTestnet,
 				features.PraterTestnet,
 				cmd.AcceptTosFlag,
 			}),
@@ -121,7 +118,6 @@ var Commands = &cli.Command{
 				flags.AccountPasswordFileFlag,
 				flags.ImportPrivateKeyFileFlag,
 				features.Mainnet,
-				features.PyrmontTestnet,
 				features.PraterTestnet,
 				cmd.AcceptTosFlag,
 			}),
@@ -155,7 +151,6 @@ var Commands = &cli.Command{
 				flags.GrpcRetryDelayFlag,
 				flags.ExitAllFlag,
 				features.Mainnet,
-				features.PyrmontTestnet,
 				features.PraterTestnet,
 				cmd.AcceptTosFlag,
 			}),

cmd/validator/slashing-protection/slashing-protection.go

@@ -22,7 +22,6 @@ var Commands = &cli.Command{
 				cmd.DataDirFlag,
 				flags.SlashingProtectionExportDirFlag,
 				features.Mainnet,
-				features.PyrmontTestnet,
 				features.PraterTestnet,
 				cmd.AcceptTosFlag,
 			}),
@@ -47,7 +46,6 @@ var Commands = &cli.Command{
 				cmd.DataDirFlag,
 				flags.SlashingProtectionJSONFileFlag,
 				features.Mainnet,
-				features.PyrmontTestnet,
 				features.PraterTestnet,
 				cmd.AcceptTosFlag,
 			}),

cmd/validator/wallet/wallet.go

@@ -34,7 +34,6 @@ var Commands = &cli.Command{
 				flags.Mnemonic25thWordFileFlag,
 				flags.SkipMnemonic25thWordCheckFlag,
 				features.Mainnet,
-				features.PyrmontTestnet,
 				features.PraterTestnet,
 				cmd.AcceptTosFlag,
 			}),
@@ -64,7 +63,6 @@ var Commands = &cli.Command{
 				flags.RemoteSignerKeyPathFlag,
 				flags.RemoteSignerCACertPathFlag,
 				features.Mainnet,
-				features.PyrmontTestnet,
 				features.PraterTestnet,
 				cmd.AcceptTosFlag,
 			}),
@@ -93,7 +91,6 @@ var Commands = &cli.Command{
 				flags.Mnemonic25thWordFileFlag,
 				flags.SkipMnemonic25thWordCheckFlag,
 				features.Mainnet,
-				features.PyrmontTestnet,
 				features.PraterTestnet,
 				cmd.AcceptTosFlag,
 			}),

config/features/config.go

@@ -35,9 +35,6 @@ const disabledFeatureFlag = "Disabled feature flag"
 
 // Flags is a struct to represent which features the client will perform on runtime.
 type Flags struct {
-	// Testnet Flags.
-	PyrmontTestnet bool // PyrmontTestnet defines the flag through which we can enable the node to run on the Pyrmont testnet.
-
 	// Feature related flags.
 	RemoteSlasherProtection             bool // RemoteSlasherProtection utilizes a beacon node with --slasher mode for validator slashing protection.
 	WriteSSZStateTransitions            bool // WriteSSZStateTransitions to tmp directory.
@@ -121,13 +118,8 @@ func InitWithReset(c *Flags) func() {
 }
 
 // configureTestnet sets the config according to specified testnet flag
-func configureTestnet(ctx *cli.Context, cfg *Flags) {
-	if ctx.Bool(PyrmontTestnet.Name) {
-		log.Warn("Running on Pyrmont Testnet")
-		params.UsePyrmontConfig()
-		params.UsePyrmontNetworkConfig()
-		cfg.PyrmontTestnet = true
-	} else if ctx.Bool(PraterTestnet.Name) {
+func configureTestnet(ctx *cli.Context) {
+	if ctx.Bool(PraterTestnet.Name) {
 		log.Warn("Running on the Prater Testnet")
 		params.UsePraterConfig()
 		params.UsePraterNetworkConfig()
@@ -145,7 +137,7 @@ func ConfigureBeaconChain(ctx *cli.Context) {
 	if ctx.Bool(devModeFlag.Name) {
 		enableDevModeFlags(ctx)
 	}
-	configureTestnet(ctx, cfg)
+	configureTestnet(ctx)
 
 	if ctx.Bool(writeSSZStateTransitionsFlag.Name) {
 		logEnabled(writeSSZStateTransitionsFlag)
@@ -240,7 +232,7 @@ func ConfigureBeaconChain(ctx *cli.Context) {
 func ConfigureValidator(ctx *cli.Context) {
 	complainOnDeprecatedFlags(ctx)
 	cfg := &Flags{}
-	configureTestnet(ctx, cfg)
+	configureTestnet(ctx)
 	if ctx.Bool(enableExternalSlasherProtectionFlag.Name) {
 		log.Fatal(
 			"Remote slashing protection has currently been disabled in Prysm due to safety concerns. " +

config/features/config_test.go

@@ -11,41 +11,41 @@ import (
 func TestInitFeatureConfig(t *testing.T) {
 	defer Init(&Flags{})
 	cfg := &Flags{
-		PyrmontTestnet: true,
+		EnablePeerScorer: true,
 	}
 	Init(cfg)
 	c := Get()
-	assert.Equal(t, true, c.PyrmontTestnet)
+	assert.Equal(t, true, c.EnablePeerScorer)
 
 	// Reset back to false for the follow up tests.
-	cfg = &Flags{PyrmontTestnet: false}
+	cfg = &Flags{RemoteSlasherProtection: false}
 	Init(cfg)
 }
 
 func TestInitWithReset(t *testing.T) {
 	defer Init(&Flags{})
 	Init(&Flags{
-		PyrmontTestnet: true,
+		EnablePeerScorer: true,
 	})
-	assert.Equal(t, true, Get().PyrmontTestnet)
+	assert.Equal(t, true, Get().EnablePeerScorer)
 
 	// Overwrite previously set value (value that didn't come by default).
 	resetCfg := InitWithReset(&Flags{
-		PyrmontTestnet: false,
+		EnablePeerScorer: false,
 	})
-	assert.Equal(t, false, Get().PyrmontTestnet)
+	assert.Equal(t, false, Get().EnablePeerScorer)
 
 	// Reset must get to previously set configuration (not to default config values).
 	resetCfg()
-	assert.Equal(t, true, Get().PyrmontTestnet)
+	assert.Equal(t, true, Get().EnablePeerScorer)
 }
 
 func TestConfigureBeaconConfig(t *testing.T) {
 	app := cli.App{}
 	set := flag.NewFlagSet("test", 0)
-	set.Bool(PyrmontTestnet.Name, true, "test")
+	set.Bool(enablePeerScorer.Name, true, "test")
 	context := cli.NewContext(&app, set, nil)
 	ConfigureBeaconChain(context)
 	c := Get()
-	assert.Equal(t, true, c.PyrmontTestnet)
+	assert.Equal(t, true, c.EnablePeerScorer)
 }

config/features/deprecated_flags.go

@@ -70,6 +70,11 @@ var (
 		Usage:  deprecatedUsage,
 		Hidden: true,
 	}
+	deprecatedPyrmontTestnet = &cli.BoolFlag{
+		Name:   "pyrmont",
+		Usage:  deprecatedUsage,
+		Hidden: true,
+	}
 )
 
 var deprecatedFlags = []cli.Flag{
@@ -84,4 +89,5 @@ var deprecatedFlags = []cli.Flag{
 	deprecatedDisableNextSlotStateCache,
 	deprecatedAttestationAggregationStrategy,
 	deprecatedForceOptMaxCoverAggregationStategy,
+	deprecatedPyrmontTestnet,
 }

config/features/flags.go

@@ -7,11 +7,6 @@ import (
 )
 
 var (
-	// PyrmontTestnet flag for the multiclient Ethereum consensus testnet.
-	PyrmontTestnet = &cli.BoolFlag{
-		Name:  "pyrmont",
-		Usage: "This defines the flag through which we can run on the Pyrmont Multiclient Testnet",
-	}
 	// PraterTestnet flag for the multiclient Ethereum consensus testnet.
 	PraterTestnet = &cli.BoolFlag{
 		Name:  "prater",
@@ -156,7 +151,6 @@ var ValidatorFlags = append(deprecatedFlags, []cli.Flag{
 	writeWalletPasswordOnWebOnboarding,
 	enableExternalSlasherProtectionFlag,
 	disableAttestingHistoryDBCache,
-	PyrmontTestnet,
 	PraterTestnet,
 	Mainnet,
 	dynamicKeyReloadDebounceInterval,
@@ -175,7 +169,6 @@ var BeaconChainFlags = append(deprecatedFlags, []cli.Flag{
 	devModeFlag,
 	writeSSZStateTransitionsFlag,
 	disableGRPCConnectionLogging,
-	PyrmontTestnet,
 	PraterTestnet,
 	Mainnet,
 	enablePeerScorer,

config/params/BUILD.bazel

@@ -13,7 +13,6 @@ go_library(
         "network_config.go",
         "testnet_e2e_config.go",
         "testnet_prater_config.go",
-        "testnet_pyrmont_config.go",
         "testutils.go",
         "values.go",
     ],

config/params/testnet_pyrmont_config.go

@@ -1,43 +0,0 @@
-package params
-
-import "math"
-
-// UsePyrmontNetworkConfig uses the Pyrmont specific
-// network config.
-func UsePyrmontNetworkConfig() {
-	cfg := BeaconNetworkConfig().Copy()
-	cfg.ContractDeploymentBlock = 3743587
-	cfg.BootstrapNodes = []string{
-		"enr:-Ku4QOA5OGWObY8ep_x35NlGBEj7IuQULTjkgxC_0G1AszqGEA0Wn2RNlyLFx9zGTNB1gdFBA6ZDYxCgIza1uJUUOj4Dh2F0dG5ldHOIAAAAAAAAAACEZXRoMpDVTPWXAAAgCf__________gmlkgnY0gmlwhDQPSjiJc2VjcDI1NmsxoQM6yTQB6XGWYJbI7NZFBjp4Yb9AYKQPBhVrfUclQUobb4N1ZHCCIyg",
-		"enr:-Ku4QOksdA2tabOGrfOOr6NynThMoio6Ggka2oDPqUuFeWCqcRM2alNb8778O_5bK95p3EFt0cngTUXm2H7o1jkSJ_8Dh2F0dG5ldHOIAAAAAAAAAACEZXRoMpDVTPWXAAAgCf__________gmlkgnY0gmlwhDaa13aJc2VjcDI1NmsxoQKdNQJvnohpf0VO0ZYCAJxGjT0uwJoAHbAiBMujGjK0SoN1ZHCCIyg",
-	}
-	OverrideBeaconNetworkConfig(cfg)
-}
-
-// UsePyrmontConfig sets the main beacon chain
-// config for Pyrmont.
-func UsePyrmontConfig() {
-	beaconConfig = PyrmontConfig()
-}
-
-// PyrmontConfig defines the config for the
-// Pyrmont testnet.
-func PyrmontConfig() *BeaconChainConfig {
-	cfg := MainnetConfig().Copy()
-	cfg.MinGenesisTime = 1605700800
-	cfg.GenesisDelay = 432000
-	cfg.ConfigName = ConfigNames[Pyrmont]
-	cfg.GenesisForkVersion = []byte{0x00, 0x00, 0x20, 0x09}
-	cfg.AltairForkVersion = []byte{0x01, 0x00, 0x20, 0x09}
-	cfg.AltairForkEpoch = 61650
-	cfg.BellatrixForkVersion = []byte{0x02, 0x00, 0x20, 0x09}
-	cfg.BellatrixForkEpoch = math.MaxUint64
-	cfg.ShardingForkVersion = []byte{0x03, 0x00, 0x20, 0x09}
-	cfg.ShardingForkEpoch = math.MaxUint64
-	cfg.SecondsPerETH1Block = 14
-	cfg.DepositChainID = 5
-	cfg.DepositNetworkID = 5
-	cfg.DepositContractAddress = "0x8c5fecdC472E27Bc447696F431E425D02dd46a8c"
-	cfg.InitializeForkSchedule()
-	return cfg
-}

config/params/values.go

@@ -12,7 +12,6 @@ const (
 	Mainnet ConfigName = iota
 	Minimal
 	EndToEnd
-	Pyrmont
 	Prater
 	EndToEndMainnet
 )
@@ -33,7 +32,6 @@ var ConfigNames = map[ConfigName]string{
 	Mainnet:         "mainnet",
 	Minimal:         "minimal",
 	EndToEnd:        "end-to-end",
-	Pyrmont:         "pyrmont",
 	Prater:          "prater",
 	EndToEndMainnet: "end-to-end-mainnet",
 }
@@ -42,7 +40,6 @@ var ConfigNames = map[ConfigName]string{
 var KnownConfigs = map[ConfigName]func() *BeaconChainConfig{
 	Mainnet:         MainnetConfig,
 	Prater:          PraterConfig,
-	Pyrmont:         PyrmontConfig,
 	Minimal:         MinimalSpecConfig,
 	EndToEnd:        E2ETestConfig,
 	EndToEndMainnet: E2EMainnetTestConfig,

consensus-types/interfaces.go

@@ -0,0 +1,72 @@
+package consensus_types
+
+import (
+	ssz "github.com/ferranbt/fastssz"
+	types "github.com/prysmaticlabs/eth2-types"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	validatorpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/validator-client"
+	"google.golang.org/protobuf/proto"
+)
+
+// SSZItem defines a struct which provides Marshal,
+// Unmarshal, and HashTreeRoot SSZ operations.
+type SSZItem interface {
+	ssz.Marshaler
+	ssz.Unmarshaler
+	ssz.HashRoot
+}
+
+// Container defines the base methods required for a consensus
+// data structure used in Prysm, containing utilities for SSZ
+// as well as conversion methods to a protobuf representation for use
+// with Prysm's gRPC API.
+type Container interface {
+	SSZItem
+	IsNil() bool
+	Proto() proto.Message
+	FromProto(m proto.Message)
+}
+
+// SignedBeaconBlock describes the method set of a signed beacon block.
+type SignedBeaconBlock interface {
+	Container
+	Block() BeaconBlock
+	Signature() []byte
+	Copy() SignedBeaconBlock
+	PbGenericBlock() (*ethpb.GenericSignedBeaconBlock, error)
+	PbPhase0Block() (*ethpb.SignedBeaconBlock, error)
+	PbAltairBlock() (*ethpb.SignedBeaconBlockAltair, error)
+	PbBellatrixBlock() (*ethpb.SignedBeaconBlockBellatrix, error)
+	PbBlindedBellatrixBlock() (*ethpb.SignedBlindedBeaconBlockBellatrix, error)
+	Header() (*ethpb.SignedBeaconBlockHeader, error)
+}
+
+// BeaconBlock describes an interface which states the methods
+// employed by an object that is a beacon block.
+type BeaconBlock interface {
+	Container
+	Slot() types.Slot
+	ProposerIndex() types.ValidatorIndex
+	ParentRoot() []byte
+	StateRoot() []byte
+	Body() BeaconBlockBody
+	AsSignRequestObject() validatorpb.SignRequestObject
+}
+
+// BeaconBlockBody describes the method set employed by an object
+// that is a beacon block body.
+type BeaconBlockBody interface {
+	Container
+	RandaoReveal() []byte
+	Eth1Data() *ethpb.Eth1Data
+	Graffiti() []byte
+	ProposerSlashings() []*ethpb.ProposerSlashing
+	AttesterSlashings() []*ethpb.AttesterSlashing
+	Attestations() []*ethpb.Attestation
+	Deposits() []*ethpb.Deposit
+	VoluntaryExits() []*ethpb.SignedVoluntaryExit
+	SyncAggregate() (*ethpb.SyncAggregate, error)
+	ExecutionPayload() (*enginev1.ExecutionPayload, error)
+	ExecutionPayloadHeader() (*ethpb.ExecutionPayloadHeader, error)
+}

deps.bzl

@@ -3756,6 +3756,13 @@ def prysm_deps():
         sum = "h1:qph92Y649prgesehzOrQjdWyxFOp/QVM+6imKHad91M=",
         version = "v2.3.0",
     )
+    go_repository(
+        name = "com_github_uudashr_gocognit",
+        importpath = "github.com/uudashr/gocognit",
+        sum = "h1:rrSex7oHr3/pPLQ0xoWq108XMU8s678FJcQ+aSfOHa4=",
+        version = "v1.0.5",
+    )
+
     go_repository(
         name = "com_github_valyala_bytebufferpool",
         importpath = "github.com/valyala/bytebufferpool",

go.mod

@@ -77,6 +77,7 @@ require (
 	github.com/trailofbits/go-mutexasserts v0.0.0-20200708152505-19999e7d3cef
 	github.com/tyler-smith/go-bip39 v1.1.0
 	github.com/urfave/cli/v2 v2.3.0
+	github.com/uudashr/gocognit v1.0.5
 	github.com/wealdtech/go-bytesutil v1.1.1
 	github.com/wealdtech/go-eth2-util v1.6.3
 	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.3

go.sum

@@ -1358,6 +1358,8 @@ github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijb
 github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/urfave/cli/v2 v2.3.0 h1:qph92Y649prgesehzOrQjdWyxFOp/QVM+6imKHad91M=
 github.com/urfave/cli/v2 v2.3.0/go.mod h1:LJmUH05zAU44vOAcrfzZQKsZbVcdbOG8rtL3/XcUArI=
+github.com/uudashr/gocognit v1.0.5 h1:rrSex7oHr3/pPLQ0xoWq108XMU8s678FJcQ+aSfOHa4=
+github.com/uudashr/gocognit v1.0.5/go.mod h1:wgYz0mitoKOTysqxTDMOUXg+Jb5SvtihkfmugIZYpEA=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
 github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
@@ -1804,6 +1806,7 @@ golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4f
 golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
 golang.org/x/tools v0.1.1-0.20210205202024-ef80cdb6ec6d/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU=
 golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.8 h1:P1HhGGuLW4aAclzjtmJdf0mJOjVUZUzOTqkAkWL+l6w=
 golang.org/x/tools v0.1.8/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

nogo_config.json

@@ -170,5 +170,13 @@
       "rules_go_work-.*": "Third party code",
       ".*_test\\.go": "Tests are ok"
     }
+  },
+  "gocognit": {
+    "exclude_files": {
+      "external/.*": "Third party code",
+      "rules_go_work-.*": "Third party code",
+      ".*\\.pb.*.go": "Generated code is ok",
+      ".*generated\\.ssz\\.go": "Generated code is ok"
+    }
   }
 }

proto/engine/v1/json_marshal_unmarshal_test.go

@@ -5,6 +5,7 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
@@ -173,6 +174,13 @@ func TestJsonMarshalUnmarshal(t *testing.T) {
 		require.DeepEqual(t, [][]byte{[]byte("hi")}, payloadPb.Transactions)
 		require.DeepEqual(t, [][]byte{[]byte("bye")}, payloadPb.Uncles)
 	})
+	t.Run("nil execution block", func(t *testing.T) {
+		jsonPayload := (*enginev1.ExecutionBlock)(nil)
+		enc, err := json.Marshal(jsonPayload)
+		require.NoError(t, err)
+		payloadPb := &enginev1.ExecutionBlock{}
+		require.ErrorIs(t, hexutil.ErrEmptyString, json.Unmarshal(enc, payloadPb))
+	})
 }
 
 func TestPayloadIDBytes_MarshalUnmarshalJSON(t *testing.T) {

tools/analyzers/gocognit/BUILD.bazel

@@ -0,0 +1,14 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["analyzer.go"],
+    importpath = "github.com/prysmaticlabs/prysm/tools/analyzers/gocognit",
+    visibility = ["//visibility:public"],
+    deps = [
+        "@com_github_uudashr_gocognit//:go_default_library",
+        "@org_golang_x_tools//go/analysis:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/inspect:go_default_library",
+        "@org_golang_x_tools//go/ast/inspector:go_default_library",
+    ],
+)

tools/analyzers/gocognit/README.md

@@ -0,0 +1,195 @@
+> Copied from https://github.com/uudashr/gocognit/blob/5bf67146515e79acd2a8d5728deafa9d91ad48db/README.md
+> License: MIT
+
+[![GoDoc](https://godoc.org/github.com/uudashr/gocognit?status.svg)](https://godoc.org/github.com/uudashr/gocognit)
+# Gocognit
+Gocognit calculates cognitive complexities of functions in Go source code. A measurement of how hard does the code is intuitively to understand.
+
+## Understanding the complexity
+
+Given code using `if` statement,
+```go
+func GetWords(number int) string {
+    if number == 1 {            // +1
+        return "one"
+    } else if number == 2 {     // +1
+        return "a couple"
+    } else if number == 3 {     // +1
+        return "a few"
+    } else {                    // +1
+        return "lots"
+    }
+} // Cognitive complexity = 4
+```
+
+Above code can be refactored using `switch` statement,
+```go
+func GetWords(number int) string {
+    switch number {             // +1
+        case 1:
+            return "one"
+        case 2:
+            return "a couple"
+        case 3:
+            return "a few"
+        default:
+            return "lots"
+    }
+} // Cognitive complexity = 1
+```
+
+As you see above codes are the same, but the second code are easier to understand, that is why the cognitive complexity score are lower compare to the first one.
+
+## Comparison with cyclometic complexity
+
+### Example 1
+#### Cyclometic complexity
+```go
+func GetWords(number int) string {      // +1
+    switch number {
+        case 1:                         // +1
+            return "one"
+        case 2:                         // +1
+            return "a couple"
+        case 3:                         // +1
+             return "a few"
+        default:
+             return "lots"
+    }
+} // Cyclomatic complexity = 4
+```
+
+####  Cognitive complexity
+```go
+func GetWords(number int) string {
+    switch number {                     // +1
+        case 1:
+            return "one"
+        case 2:
+            return "a couple"
+        case 3:
+            return "a few"
+        default:
+            return "lots"
+    }
+} // Cognitive complexity = 1
+```
+
+Cognitive complexity give lower score compare to cyclomatic complexity.
+
+### Example 2
+#### Cyclomatic complexity
+```go
+func SumOfPrimes(max int) int {         // +1
+    var total int
+
+OUT:
+    for i := 1; i < max; i++ {          // +1
+        for j := 2; j < i; j++ {        // +1
+            if i%j == 0 {               // +1
+                continue OUT
+            }
+        }
+        total += i
+    }
+
+    return total
+} // Cyclomatic complexity = 4
+```
+
+#### Cognitive complexity
+```go
+func SumOfPrimes(max int) int {
+    var total int
+
+OUT:
+    for i := 1; i < max; i++ {          // +1
+        for j := 2; j < i; j++ {        // +2 (nesting = 1)
+            if i%j == 0 {               // +3 (nesting = 2)
+                continue OUT            // +1
+            }
+        }
+        total += i
+    }
+
+    return total
+} // Cognitive complexity = 7
+```
+
+Cognitive complexity give higher score compare to cyclomatic complexity.
+
+## Rules
+
+The cognitive complexity of a function is calculated according to the
+following rules:
+> Note: these rules are specific for Go, please see the [original whitepaper](./CognitiveComplexity.pdf) for more complete reference.
+
+### Increments
+There is an increment for each of the following:
+1. `if`, `else if`, `else`
+2. `switch`, `select`
+3. `for`
+4. `goto` LABEL, `break` LABEL, `continue` LABEL
+5. sequence of binary logical operators
+6. each method in a recursion cycle
+
+### Nesting level
+The following structures increment the nesting level:
+1. `if`, `else if`, `else`
+2. `switch`, `select`
+3. `for`
+4. function literal or lambda
+
+### Nesting increments
+The following structures receive a nesting increment commensurate with their nested depth inside nesting structures:
+1. `if`
+2. `switch`, `select`
+3. `for`
+
+## Installation
+
+```
+$ go install github.com/uudashr/gocognit/cmd/gocognit@latest
+```
+
+or 
+
+```
+$ go get github.com/uudashr/gocognit/cmd/gocognit
+```
+
+## Usage
+
+```
+$ gocognit
+Calculate cognitive complexities of Go functions.
+Usage:
+        gocognit [flags] <Go file or directory> ...
+Flags:
+        -over N   show functions with complexity > N only and
+                  return exit code 1 if the set is non-empty
+        -top N    show the top N most complex functions only
+        -avg      show the average complexity over all functions,
+                  not depending on whether -over or -top are set
+The output fields for each line are:
+<complexity> <package> <function> <file:row:column>
+```
+
+Examples:
+
+```
+$ gocognit .
+$ gocognit main.go
+$ gocognit -top 10 src/
+$ gocognit -over 25 docker
+$ gocognit -avg .
+```
+
+The output fields for each line are:
+```
+<complexity> <package> <function> <file:row:column>
+```
+
+## Related project
+- [Gocyclo](https://github.com/fzipp/gocyclo) where the code are based on.
+- [Cognitive Complexity: A new way of measuring understandability](./CognitiveComplexity.pdf) white paper by G. Ann Campbell.

tools/analyzers/gocognit/analyzer.go

@@ -0,0 +1,90 @@
+package gocognit
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+
+	"github.com/uudashr/gocognit"
+	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/go/analysis/passes/inspect"
+	"golang.org/x/tools/go/ast/inspector"
+)
+
+// Doc explaining the tool.
+const Doc = "Tool to ensure go code does not have high cognitive complexity."
+
+// Analyzer runs static analysis.
+var Analyzer = &analysis.Analyzer{
+	Name:     "gocognit",
+	Doc:      Doc,
+	Requires: []*analysis.Analyzer{inspect.Analyzer},
+	Run:      run,
+}
+
+// Recommended thresholds according to the 2008 presentation titled
+// "Software Quality Metrics to Identify Risk" by Thomas McCabe Jr.
+//
+//  1 - 10 Simple procedure, little risk
+// 11 - 20 More complex, moderate risk
+// 21 - 50 Complex, high risk
+// > 50 Untestable code, very high risk
+//
+// This threshold should be lowered to 50 over time.
+const over = 130
+
+func run(pass *analysis.Pass) (interface{}, error) {
+	inspect, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+	if !ok {
+		return nil, errors.New("analyzer is not type *inspector.Inspector")
+	}
+
+	nodeFilter := []ast.Node{
+		(*ast.FuncDecl)(nil),
+	}
+	inspect.Preorder(nodeFilter, func(n ast.Node) {
+		fnDecl, ok := n.(*ast.FuncDecl)
+		if !ok {
+			return
+		}
+
+		fnName := funcName(fnDecl)
+		fnComplexity := gocognit.Complexity(fnDecl)
+
+		if fnComplexity > over {
+			pass.Reportf(fnDecl.Pos(), "cognitive complexity %d of func %s is high (> %d)", fnComplexity, fnName, over)
+		}
+	})
+
+	return nil, nil
+}
+
+// funcName returns the name representation of a function or method:
+// "(Type).Name" for methods or simply "Name" for functions.
+//
+// Copied from https://github.com/uudashr/gocognit/blob/5bf67146515e79acd2a8d5728deafa9d91ad48db/gocognit.go
+// License: MIT
+func funcName(fn *ast.FuncDecl) string {
+	if fn.Recv != nil {
+		if fn.Recv.NumFields() > 0 {
+			typ := fn.Recv.List[0].Type
+			return fmt.Sprintf("(%s).%s", recvString(typ), fn.Name)
+		}
+	}
+	return fn.Name.Name
+}
+
+// recvString returns a string representation of recv of the
+// form "T", "*T", or "BADRECV" (if not a proper receiver type).
+//
+// Copied from https://github.com/uudashr/gocognit/blob/5bf67146515e79acd2a8d5728deafa9d91ad48db/gocognit.go
+// License: MIT
+func recvString(recv ast.Expr) string {
+	switch t := recv.(type) {
+	case *ast.Ident:
+		return t.Name
+	case *ast.StarExpr:
+		return "*" + recvString(t.X)
+	}
+	return "BADRECV"
+}

tools/eth1voting/README.md

@@ -7,7 +7,7 @@ Flags:
   -beacon string
         gRPC address of the Prysm beacon node (default "127.0.0.1:4000")
   -genesis uint
-        Genesis time. mainnet=1606824023, prater=1616508000, pyrmont=1605722407 (default 1606824023)
+        Genesis time. mainnet=1606824023, prater=1616508000 (default 1606824023)
 ```
 
 Usage:

tools/eth1voting/main.go

@@ -18,7 +18,7 @@ import (
 
 var (
 	beacon  = flag.String("beacon", "127.0.0.1:4000", "gRPC address of the Prysm beacon node")
-	genesis = flag.Uint64("genesis", 1606824023, "Genesis time. mainnet=1606824023, prater=1616508000, pyrmont=1605722407")
+	genesis = flag.Uint64("genesis", 1606824023, "Genesis time. mainnet=1606824023, prater=1616508000")
 )
 
 func main() {

validator/accounts/accounts_exit.go

@@ -276,9 +276,7 @@ func displayExitInfo(rawExitedKeys [][]byte, trimmedExitedKeys []string) {
 		urlFormattedPubKeys := make([]string, len(rawExitedKeys))
 		for i, key := range rawExitedKeys {
 			var baseUrl string
-			if params.BeaconConfig().ConfigName == params.ConfigNames[params.Pyrmont] {
-				baseUrl = "https://pyrmont.beaconcha.in/validator/"
-			} else if params.BeaconConfig().ConfigName == params.ConfigNames[params.Prater] {
+			if params.BeaconConfig().ConfigName == params.ConfigNames[params.Prater] {
 				baseUrl = "https://prater.beaconcha.in/validator/"
 			} else {
 				baseUrl = "https://beaconcha.in/validator/"