diff --git a/beacon-chain/blockchain/chain_info.go b/beacon-chain/blockchain/chain_info.go index f36ef454cd..953cf127b8 100644 --- a/beacon-chain/blockchain/chain_info.go +++ b/beacon-chain/blockchain/chain_info.go @@ -328,7 +328,7 @@ func (s *Service) IsOptimistic(ctx context.Context) (bool, error) { return s.IsOptimisticForRoot(ctx, s.head.root) } -// IsOptimisticForRoot takes the root and slot as aguments instead of the current head +// IsOptimisticForRoot takes the root and slot as arguments instead of the current head // and returns true if it is optimistic. func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error) { optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(ctx, root) diff --git a/beacon-chain/blockchain/error.go b/beacon-chain/blockchain/error.go index 98bbecb808..868bfd3b46 100644 --- a/beacon-chain/blockchain/error.go +++ b/beacon-chain/blockchain/error.go @@ -13,7 +13,7 @@ var ( errInvalidNilSummary = errors.New("nil summary returned from the DB") // errNilParentInDB is returned when a nil parent block is returned from the DB. errNilParentInDB = errors.New("nil parent block in DB") - // errWrongBlockCound is returned when the wrong number of blocks or + // errWrongBlockCount is returned when the wrong number of blocks or // block roots is used errWrongBlockCount = errors.New("wrong number of blocks or block roots") ) diff --git a/beacon-chain/blockchain/new_slot_test.go b/beacon-chain/blockchain/new_slot_test.go index 470ed9b537..bc3a2c5206 100644 --- a/beacon-chain/blockchain/new_slot_test.go +++ b/beacon-chain/blockchain/new_slot_test.go @@ -86,9 +86,9 @@ func TestService_newSlot(t *testing.T) { for _, test := range tests { service, err := NewService(ctx, opts...) require.NoError(t, err) - store := store.New(test.args.justified, test.args.finalized) - store.SetBestJustifiedCheckpt(test.args.bestJustified) - service.store = store + s := store.New(test.args.justified, test.args.finalized) + s.SetBestJustifiedCheckpt(test.args.bestJustified) + service.store = s require.NoError(t, service.NewSlot(ctx, test.args.slot)) if test.args.shouldEqual { diff --git a/beacon-chain/blockchain/optimistic_sync_test.go b/beacon-chain/blockchain/optimistic_sync_test.go index e7d988f394..0b8f19f3aa 100644 --- a/beacon-chain/blockchain/optimistic_sync_test.go +++ b/beacon-chain/blockchain/optimistic_sync_test.go @@ -155,8 +155,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - engine := &mockEngineService{forkchoiceError: tt.newForkchoiceErr} - service.cfg.ExecutionEngineCaller = engine + service.cfg.ExecutionEngineCaller = &mockEngineService{forkchoiceError: tt.newForkchoiceErr} _, err := service.notifyForkchoiceUpdate(ctx, tt.blk, service.headRoot(), tt.finalizedRoot) if tt.errString != "" { require.ErrorContains(t, tt.errString, err) @@ -328,16 +327,16 @@ func Test_NotifyNewPayload(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - engine := &mockEngineService{newPayloadError: tt.newPayloadErr, blks: map[[32]byte]*v1.ExecutionBlock{}} - engine.blks[[32]byte{'a'}] = &v1.ExecutionBlock{ + e := &mockEngineService{newPayloadError: tt.newPayloadErr, blks: map[[32]byte]*v1.ExecutionBlock{}} + e.blks[[32]byte{'a'}] = &v1.ExecutionBlock{ ParentHash: bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength), TotalDifficulty: "0x2", } - engine.blks[[32]byte{'b'}] = &v1.ExecutionBlock{ + e.blks[[32]byte{'b'}] = &v1.ExecutionBlock{ ParentHash: bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength), TotalDifficulty: "0x1", } - service.cfg.ExecutionEngineCaller = engine + service.cfg.ExecutionEngineCaller = e var payload *ethpb.ExecutionPayloadHeader if tt.preState.Version() == version.Bellatrix { payload, err = tt.preState.LatestExecutionPayloadHeader() @@ -383,16 +382,16 @@ func Test_NotifyNewPayload_SetOptimisticToValid(t *testing.T) { require.NoError(t, err) service, err := NewService(ctx, opts...) require.NoError(t, err) - engine := &mockEngineService{blks: map[[32]byte]*v1.ExecutionBlock{}} - engine.blks[[32]byte{'a'}] = &v1.ExecutionBlock{ + e := &mockEngineService{blks: map[[32]byte]*v1.ExecutionBlock{}} + e.blks[[32]byte{'a'}] = &v1.ExecutionBlock{ ParentHash: bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength), TotalDifficulty: "0x2", } - engine.blks[[32]byte{'b'}] = &v1.ExecutionBlock{ + e.blks[[32]byte{'b'}] = &v1.ExecutionBlock{ ParentHash: bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength), TotalDifficulty: "0x1", } - service.cfg.ExecutionEngineCaller = engine + service.cfg.ExecutionEngineCaller = e payload, err := bellatrixState.LatestExecutionPayloadHeader() require.NoError(t, err) root := [32]byte{'c'} @@ -443,7 +442,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) { blk := util.NewBeaconBlockBellatrix() blk.Block.Slot = 1 blk.Block.ParentRoot = parentRoot[:] - wr, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block) + wr, err := wrapper.WrappedBeaconBlock(blk.Block) require.NoError(tt, err) return wr }(t), @@ -463,7 +462,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) { blk := util.NewBeaconBlockAltair() blk.Block.Slot = 200 blk.Block.ParentRoot = parentRoot[:] - wr, err := wrapper.WrappedAltairBeaconBlock(blk.Block) + wr, err := wrapper.WrappedBeaconBlock(blk.Block) require.NoError(tt, err) return wr }(t), @@ -483,7 +482,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) { blk := util.NewBeaconBlockBellatrix() blk.Block.Slot = 200 blk.Block.ParentRoot = parentRoot[:] - wr, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block) + wr, err := wrapper.WrappedBeaconBlock(blk.Block) require.NoError(tt, err) return wr }(t), @@ -503,7 +502,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) { blk := util.NewBeaconBlockBellatrix() blk.Block.Slot = 200 blk.Block.ParentRoot = parentRoot[:] - wr, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block) + wr, err := wrapper.WrappedBeaconBlock(blk.Block) require.NoError(tt, err) return wr }(t), @@ -527,12 +526,12 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) { }, } for _, tt := range tests { - jroot, err := tt.justified.Block().HashTreeRoot() + jRoot, err := tt.justified.Block().HashTreeRoot() require.NoError(t, err) require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, tt.justified)) service.store.SetJustifiedCheckpt( ðpb.Checkpoint{ - Root: jroot[:], + Root: jRoot[:], Epoch: slots.ToEpoch(tt.justified.Block().Slot()), }) require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrappedParentBlock)) @@ -571,8 +570,8 @@ func Test_IsOptimisticShallowExecutionParent(t *testing.T) { BlockNumber: 100, } body := ðpb.BeaconBlockBodyBellatrix{ExecutionPayload: payload} - block := ðpb.BeaconBlockBellatrix{Body: body, Slot: 200} - rawSigned := ðpb.SignedBeaconBlockBellatrix{Block: block} + b := ðpb.BeaconBlockBellatrix{Body: body, Slot: 200} + rawSigned := ðpb.SignedBeaconBlockBellatrix{Block: b} blk := util.HydrateSignedBeaconBlockBellatrix(rawSigned) wr, err := wrapper.WrappedSignedBeaconBlock(blk) require.NoError(t, err) diff --git a/beacon-chain/blockchain/process_block_test.go b/beacon-chain/blockchain/process_block_test.go index c53e4d44df..8a2ae72ce3 100644 --- a/beacon-chain/blockchain/process_block_test.go +++ b/beacon-chain/blockchain/process_block_test.go @@ -1628,9 +1628,9 @@ func Test_getStateVersionAndPayload(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - version, header, err := getStateVersionAndPayload(tt.st) + ver, header, err := getStateVersionAndPayload(tt.st) require.NoError(t, err) - require.Equal(t, tt.version, version) + require.Equal(t, tt.version, ver) require.DeepEqual(t, tt.header, header) }) } diff --git a/beacon-chain/blockchain/service.go b/beacon-chain/blockchain/service.go index a36810c6e4..441a191880 100644 --- a/beacon-chain/blockchain/service.go +++ b/beacon-chain/blockchain/service.go @@ -191,14 +191,14 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error { } s.store = store.New(justified, finalized) - var store f.ForkChoicer + var f f.ForkChoicer fRoot := bytesutil.ToBytes32(finalized.Root) if features.Get().EnableForkChoiceDoublyLinkedTree { - store = doublylinkedtree.New(justified.Epoch, finalized.Epoch) + f = doublylinkedtree.New(justified.Epoch, finalized.Epoch) } else { - store = protoarray.New(justified.Epoch, finalized.Epoch, fRoot) + f = protoarray.New(justified.Epoch, finalized.Epoch, fRoot) } - s.cfg.ForkChoiceStore = store + s.cfg.ForkChoiceStore = f fb, err := s.cfg.BeaconDB.Block(s.ctx, s.ensureRootNotZeros(fRoot)) if err != nil { return errors.Wrap(err, "could not get finalized checkpoint block") @@ -211,7 +211,7 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error { return errors.Wrap(err, "could not get execution payload hash") } fSlot := fb.Block().Slot() - if err := store.InsertOptimisticBlock(s.ctx, fSlot, fRoot, params.BeaconConfig().ZeroHash, + if err := f.InsertOptimisticBlock(s.ctx, fSlot, fRoot, params.BeaconConfig().ZeroHash, payloadHash, justified.Epoch, finalized.Epoch); err != nil { return errors.Wrap(err, "could not insert finalized block to forkchoice") } @@ -221,7 +221,7 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error { return errors.Wrap(err, "could not get last validated checkpoint") } if bytes.Equal(finalized.Root, lastValidatedCheckpoint.Root) { - if err := store.SetOptimisticToValid(s.ctx, fRoot); err != nil { + if err := f.SetOptimisticToValid(s.ctx, fRoot); err != nil { return errors.Wrap(err, "could not set finalized block as validated") } } @@ -362,9 +362,9 @@ func (s *Service) startFromPOWChain() error { defer stateSub.Unsubscribe() for { select { - case event := <-stateChannel: - if event.Type == statefeed.ChainStarted { - data, ok := event.Data.(*statefeed.ChainStartedData) + case e := <-stateChannel: + if e.Type == statefeed.ChainStarted { + data, ok := e.Data.(*statefeed.ChainStartedData) if !ok { log.Error("event data is not type *statefeed.ChainStartedData") return diff --git a/beacon-chain/blockchain/service_test.go b/beacon-chain/blockchain/service_test.go index f75d8120a5..78c88d56db 100644 --- a/beacon-chain/blockchain/service_test.go +++ b/beacon-chain/blockchain/service_test.go @@ -496,12 +496,12 @@ func TestHasBlock_ForkChoiceAndDB_ProtoArray(t *testing.T) { store: &store.Store{}, } s.store.SetFinalizedCheckpt(ðpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}) - block := util.NewBeaconBlock() - r, err := block.Block.HashTreeRoot() + b := util.NewBeaconBlock() + r, err := b.Block.HashTreeRoot() require.NoError(t, err) beaconState, err := util.NewBeaconState() require.NoError(t, err) - wsb, err := wrapper.WrappedSignedBeaconBlock(block) + wsb, err := wrapper.WrappedSignedBeaconBlock(b) require.NoError(t, err) require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState)) @@ -517,12 +517,12 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) { store: &store.Store{}, } s.store.SetFinalizedCheckpt(ðpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}) - block := util.NewBeaconBlock() - r, err := block.Block.HashTreeRoot() + b := util.NewBeaconBlock() + r, err := b.Block.HashTreeRoot() require.NoError(t, err) beaconState, err := util.NewBeaconState() require.NoError(t, err) - wsb, err := wrapper.WrappedSignedBeaconBlock(block) + wsb, err := wrapper.WrappedSignedBeaconBlock(b) require.NoError(t, err) require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState)) @@ -539,10 +539,10 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) { cancel: cancel, initSyncBlocks: make(map[[32]byte]block.SignedBeaconBlock), } - block := util.NewBeaconBlock() - r, err := block.Block.HashTreeRoot() + b := util.NewBeaconBlock() + r, err := b.Block.HashTreeRoot() require.NoError(t, err) - wsb, err := wrapper.WrappedSignedBeaconBlock(block) + wsb, err := wrapper.WrappedSignedBeaconBlock(b) require.NoError(t, err) s.saveInitSyncBlock(r, wsb) require.NoError(t, s.Stop()) @@ -569,11 +569,11 @@ func BenchmarkHasBlockDB(b *testing.B) { s := &Service{ cfg: &config{BeaconDB: beaconDB}, } - block := util.NewBeaconBlock() - wsb, err := wrapper.WrappedSignedBeaconBlock(block) + blk := util.NewBeaconBlock() + wsb, err := wrapper.WrappedSignedBeaconBlock(blk) require.NoError(b, err) require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wsb)) - r, err := block.Block.HashTreeRoot() + r, err := blk.Block.HashTreeRoot() require.NoError(b, err) b.ResetTimer() @@ -613,13 +613,13 @@ func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) { store: &store.Store{}, } s.store.SetFinalizedCheckpt(ðpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}) - block := ðpb.SignedBeaconBlock{Block: ðpb.BeaconBlock{Body: ðpb.BeaconBlockBody{}}} - r, err := block.Block.HashTreeRoot() + blk := ðpb.SignedBeaconBlock{Block: ðpb.BeaconBlock{Body: ðpb.BeaconBlockBody{}}} + r, err := blk.Block.HashTreeRoot() require.NoError(b, err) bs := ðpb.BeaconState{FinalizedCheckpoint: ðpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: ðpb.Checkpoint{Root: make([]byte, 32)}} beaconState, err := v1.InitializeFromProto(bs) require.NoError(b, err) - wsb, err := wrapper.WrappedSignedBeaconBlock(block) + wsb, err := wrapper.WrappedSignedBeaconBlock(blk) require.NoError(b, err) require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState)) diff --git a/beacon-chain/blockchain/state_balance_cache.go b/beacon-chain/blockchain/state_balance_cache.go index fc4b5350b3..57e7c3679c 100644 --- a/beacon-chain/blockchain/state_balance_cache.go +++ b/beacon-chain/blockchain/state_balance_cache.go @@ -24,7 +24,7 @@ type stateByRooter interface { StateByRoot(context.Context, [32]byte) (state.BeaconState, error) } -// newStateBalanceCache exists to remind us that stateBalanceCache needs a stagegen +// newStateBalanceCache exists to remind us that stateBalanceCache needs a state gen // to avoid nil pointer bugs when updating the cache in the read path (get()) func newStateBalanceCache(sg *stategen.State) (*stateBalanceCache, error) { if sg == nil { diff --git a/beacon-chain/blockchain/state_balance_cache_test.go b/beacon-chain/blockchain/state_balance_cache_test.go index 4269042c91..8e62242bb7 100644 --- a/beacon-chain/blockchain/state_balance_cache_test.go +++ b/beacon-chain/blockchain/state_balance_cache_test.go @@ -15,15 +15,6 @@ import ( "github.com/prysmaticlabs/prysm/time/slots" ) -type mockStateByRoot struct { - state state.BeaconState - err error -} - -func (m *mockStateByRoot) StateByRoot(context.Context, [32]byte) (state.BeaconState, error) { - return m.state, m.err -} - type testStateOpt func(*ethpb.BeaconStateAltair) func testStateWithValidators(v []*ethpb.Validator) testStateOpt { diff --git a/beacon-chain/blockchain/testing/mock.go b/beacon-chain/blockchain/testing/mock.go index b658cb132c..155d157ab4 100644 --- a/beacon-chain/blockchain/testing/mock.go +++ b/beacon-chain/blockchain/testing/mock.go @@ -195,26 +195,26 @@ func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []block.Signe if s.State == nil { return ErrNilState } - for _, block := range blks { - if !bytes.Equal(s.Root, block.Block().ParentRoot()) { - return errors.Errorf("wanted %#x but got %#x", s.Root, block.Block().ParentRoot()) + for _, b := range blks { + if !bytes.Equal(s.Root, b.Block().ParentRoot()) { + return errors.Errorf("wanted %#x but got %#x", s.Root, b.Block().ParentRoot()) } - if err := s.State.SetSlot(block.Block().Slot()); err != nil { + if err := s.State.SetSlot(b.Block().Slot()); err != nil { return err } - s.BlocksReceived = append(s.BlocksReceived, block) - signingRoot, err := block.Block().HashTreeRoot() + s.BlocksReceived = append(s.BlocksReceived, b) + signingRoot, err := b.Block().HashTreeRoot() if err != nil { return err } if s.DB != nil { - if err := s.DB.SaveBlock(ctx, block); err != nil { + if err := s.DB.SaveBlock(ctx, b); err != nil { return err } - logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, block.Block().Slot()) + logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, b.Block().Slot()) } s.Root = signingRoot[:] - s.Block = block + s.Block = b } return nil } @@ -417,7 +417,7 @@ func (s *ChainService) HeadValidatorIndexToPublicKey(_ context.Context, _ types. } // HeadSyncCommitteeIndices mocks HeadSyncCommitteeIndices and always return `HeadNextSyncCommitteeIndices`. -func (s *ChainService) HeadSyncCommitteeIndices(_ context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error) { +func (s *ChainService) HeadSyncCommitteeIndices(_ context.Context, _ types.ValidatorIndex, _ types.Slot) ([]types.CommitteeIndex, error) { return s.SyncCommitteeIndices, nil }