diff --git a/api/gateway/modifiers.go b/api/gateway/modifiers.go index ac036fb0cb..dab4e60894 100644 --- a/api/gateway/modifiers.go +++ b/api/gateway/modifiers.go @@ -9,7 +9,7 @@ import ( "google.golang.org/protobuf/proto" ) -func HttpResponseModifier(ctx context.Context, w http.ResponseWriter, resp proto.Message) error { +func HttpResponseModifier(ctx context.Context, w http.ResponseWriter, _ proto.Message) error { md, ok := gwruntime.ServerMetadataFromContext(ctx) if !ok { return nil diff --git a/async/multilock.go b/async/multilock.go index 4d524de057..2e81725cbc 100644 --- a/async/multilock.go +++ b/async/multilock.go @@ -49,7 +49,7 @@ func (lk *Lock) Lock() { lk.unlock <- 1 } -// Unlocks this lock. Must be called after Lock. +// Unlock unlocks this lock. Must be called after Lock. // Can only be invoked if there is a previous call to Lock. func (lk *Lock) Unlock() { <-lk.unlock @@ -65,14 +65,14 @@ func (lk *Lock) Unlock() { <-lk.lock } -// Temporarily unlocks, gives up the cpu time to other goroutine, and attempts to lock again. +// Yield temporarily unlocks, gives up the cpu time to other goroutine, and attempts to lock again. func (lk *Lock) Yield() { lk.Unlock() runtime.Gosched() lk.Lock() } -// Creates a new multilock for the specified keys +// NewMultilock creates a new multilock for the specified keys func NewMultilock(locks ...string) *Lock { if len(locks) == 0 { return nil @@ -87,7 +87,7 @@ func NewMultilock(locks ...string) *Lock { } } -// Cleans old unused locks. Returns removed keys. +// Clean cleans old unused locks. Returns removed keys. func Clean() []string { locks.lock <- 1 defer func() { <-locks.lock }() diff --git a/async/multilock_test.go b/async/multilock_test.go index 09c7416fac..b962f4dbcc 100644 --- a/async/multilock_test.go +++ b/async/multilock_test.go @@ -22,22 +22,22 @@ import ( func TestUnique(t *testing.T) { var arr []string - assert := assert.New(t) + a := assert.New(t) arr = []string{"a", "b", "c"} - assert.Equal(arr, unique(arr)) + a.Equal(arr, unique(arr)) arr = []string{"a", "a", "a"} - assert.Equal([]string{"a"}, unique(arr)) + a.Equal([]string{"a"}, unique(arr)) arr = []string{"a", "a", "b"} - assert.Equal([]string{"a", "b"}, unique(arr)) + a.Equal([]string{"a", "b"}, unique(arr)) arr = []string{"a", "b", "a"} - assert.Equal([]string{"a", "b"}, unique(arr)) + a.Equal([]string{"a", "b"}, unique(arr)) arr = []string{"a", "b", "c", "b", "d"} - assert.Equal([]string{"a", "b", "c", "d"}, unique(arr)) + a.Equal([]string{"a", "b", "c", "d"}, unique(arr)) } func TestGetChan(t *testing.T) { @@ -45,9 +45,9 @@ func TestGetChan(t *testing.T) { ch2 := getChan("aa") ch3 := getChan("a") - assert := assert.New(t) - assert.NotEqual(ch1, ch2) - assert.Equal(ch1, ch3) + a := assert.New(t) + a.NotEqual(ch1, ch2) + a.Equal(ch1, ch3) } func TestLockUnlock(_ *testing.T) { diff --git a/beacon-chain/blockchain/chain_info_test.go b/beacon-chain/blockchain/chain_info_test.go index 8afed69e35..90430107b9 100644 --- a/beacon-chain/blockchain/chain_info_test.go +++ b/beacon-chain/blockchain/chain_info_test.go @@ -309,21 +309,21 @@ func TestService_ChainHeads_ProtoArray(t *testing.T) { c := &Service{cfg: &config{ForkChoiceStore: protoarray.New()}} ojc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} ofc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} - state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) + st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) roots, slots := c.ChainHeads() require.DeepEqual(t, [][32]byte{{'c'}, {'d'}, {'e'}}, roots) @@ -341,24 +341,24 @@ func TestService_ChainHeads_DoublyLinkedTree(t *testing.T) { c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}} ojc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} ofc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} - state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) + st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) roots, slots := c.ChainHeads() require.Equal(t, 3, len(roots)) @@ -438,12 +438,12 @@ func TestService_IsOptimistic_ProtoArray(t *testing.T) { c := &Service{cfg: &config{ForkChoiceStore: protoarray.New()}, head: &head{slot: 101, root: [32]byte{'b'}}} ojc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} ofc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} - state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) + st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) opt, err := c.IsOptimistic(ctx) require.NoError(t, err) @@ -460,12 +460,12 @@ func TestService_IsOptimistic_DoublyLinkedTree(t *testing.T) { ojc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} ofc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}} - state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) + st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) opt, err := c.IsOptimistic(ctx) require.NoError(t, err) @@ -485,12 +485,12 @@ func TestService_IsOptimisticForRoot_ProtoArray(t *testing.T) { c := &Service{cfg: &config{ForkChoiceStore: protoarray.New()}, head: &head{slot: 101, root: [32]byte{'b'}}} ojc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} ofc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} - state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) + st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'}) require.NoError(t, err) @@ -502,12 +502,12 @@ func TestService_IsOptimisticForRoot_DoublyLinkedTree(t *testing.T) { c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}} ojc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} ofc := ðpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]} - state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) + st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) + require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'}) require.NoError(t, err) diff --git a/beacon-chain/blockchain/process_block_test.go b/beacon-chain/blockchain/process_block_test.go index 0c82b41128..8de349a3ed 100644 --- a/beacon-chain/blockchain/process_block_test.go +++ b/beacon-chain/blockchain/process_block_test.go @@ -966,9 +966,9 @@ func TestAncestor_CanUseForkchoice(t *testing.T) { beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32) r, err := b.Block.HashTreeRoot() require.NoError(t, err) - state, blkRoot, err := prepareForkchoiceState(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), params.BeaconConfig().ZeroHash, ojc, ofc) + st, blkRoot, err := prepareForkchoiceState(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) + require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) } r, err := service.ancestor(context.Background(), r200[:], 150) @@ -1015,9 +1015,9 @@ func TestAncestor_CanUseDB(t *testing.T) { util.SaveBlock(t, context.Background(), beaconDB, beaconBlock) } - state, blkRoot, err := prepareForkchoiceState(context.Background(), 200, r200, r200, params.BeaconConfig().ZeroHash, ojc, ofc) + st, blkRoot, err := prepareForkchoiceState(context.Background(), 200, r200, r200, params.BeaconConfig().ZeroHash, ojc, ofc) require.NoError(t, err) - require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot)) + require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot)) r, err := service.ancestor(context.Background(), r200[:], 150) require.NoError(t, err) diff --git a/beacon-chain/blockchain/service_test.go b/beacon-chain/blockchain/service_test.go index 15185a3a0c..9bcd12c670 100644 --- a/beacon-chain/blockchain/service_test.go +++ b/beacon-chain/blockchain/service_test.go @@ -11,7 +11,7 @@ import ( "github.com/prysmaticlabs/prysm/async/event" mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing" "github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache" - b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks" + "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks" "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" @@ -217,9 +217,9 @@ func TestChainService_InitializeBeaconChain(t *testing.T) { count := uint64(10) deposits, _, err := util.DeterministicDepositsAndKeys(count) require.NoError(t, err) - trie, _, err := util.DepositTrieFromDeposits(deposits) + dt, _, err := util.DepositTrieFromDeposits(deposits) require.NoError(t, err) - hashTreeRoot, err := trie.HashTreeRoot() + hashTreeRoot, err := dt.HashTreeRoot() require.NoError(t, err) genState, err := transition.EmptyGenesisState() require.NoError(t, err) @@ -229,7 +229,7 @@ func TestChainService_InitializeBeaconChain(t *testing.T) { BlockHash: make([]byte, 32), }) require.NoError(t, err) - genState, err = b.ProcessPreGenesisDeposits(ctx, genState, deposits) + genState, err = blocks.ProcessPreGenesisDeposits(ctx, genState, deposits) require.NoError(t, err) _, err = bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, ðpb.Eth1Data{DepositRoot: hashTreeRoot[:], BlockHash: make([]byte, 32)}) @@ -524,10 +524,10 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) { cancel: cancel, initSyncBlocks: make(map[[32]byte]interfaces.SignedBeaconBlock), } - b := util.NewBeaconBlock() - r, err := b.Block.HashTreeRoot() + bb := util.NewBeaconBlock() + r, err := bb.Block.HashTreeRoot() require.NoError(t, err) - wsb, err := wrapper.WrappedSignedBeaconBlock(b) + wsb, err := wrapper.WrappedSignedBeaconBlock(bb) require.NoError(t, err) require.NoError(t, s.saveInitSyncBlock(ctx, r, wsb)) require.NoError(t, s.Stop()) diff --git a/beacon-chain/cache/depositcache/deposits_cache_test.go b/beacon-chain/cache/depositcache/deposits_cache_test.go index 00ddac8f5d..7bcb101d1b 100644 --- a/beacon-chain/cache/depositcache/deposits_cache_test.go +++ b/beacon-chain/cache/depositcache/deposits_cache_test.go @@ -428,9 +428,9 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) { require.NoError(t, err, "Could not hash deposit data") deps = append(deps, hash[:]) } - trie, err := trie.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth) + generatedTrie, err := trie.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth) require.NoError(t, err, "Could not generate deposit trie") - rootA, err := trie.HashTreeRoot() + rootA, err := generatedTrie.HashTreeRoot() require.NoError(t, err) rootB, err := cachedDeposits.Deposits.HashTreeRoot() require.NoError(t, err) @@ -490,9 +490,9 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) { require.NoError(t, err, "Could not hash deposit data") deps = append(deps, hash[:]) } - trie, err := trie.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth) + generatedTrie, err := trie.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth) require.NoError(t, err, "Could not generate deposit trie") - rootA, err := trie.HashTreeRoot() + rootA, err := generatedTrie.HashTreeRoot() require.NoError(t, err) rootB, err := cachedDeposits.Deposits.HashTreeRoot() require.NoError(t, err) diff --git a/beacon-chain/cache/depositcache/pending_deposits.go b/beacon-chain/cache/depositcache/pending_deposits.go index a317d2e201..99dec1bf82 100644 --- a/beacon-chain/cache/depositcache/pending_deposits.go +++ b/beacon-chain/cache/depositcache/pending_deposits.go @@ -109,12 +109,12 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos idx := -1 for i, ctnr := range dc.pendingDeposits { - hash, err := hash.HashProto(ctnr.Deposit) + h, err := hash.HashProto(ctnr.Deposit) if err != nil { log.Errorf("Could not hash deposit %v", err) continue } - if hash == depRoot { + if h == depRoot { idx = i break } diff --git a/beacon-chain/cache/sync_committee_test.go b/beacon-chain/cache/sync_committee_test.go index 280934041f..dc28228d80 100644 --- a/beacon-chain/cache/sync_committee_test.go +++ b/beacon-chain/cache/sync_committee_test.go @@ -161,16 +161,16 @@ func TestSyncCommitteeCache_CanUpdateAndRetrieve(t *testing.T) { s, _ := util.DeterministicGenesisStateAltair(t, uint64(numValidators)) require.NoError(t, s.SetCurrentSyncCommittee(tt.currentSyncCommittee)) require.NoError(t, s.SetNextSyncCommittee(tt.nextSyncCommittee)) - cache := cache.NewSyncCommittee() + c := cache.NewSyncCommittee() r := [32]byte{'a'} - require.NoError(t, cache.UpdatePositionsInCommittee(r, s)) + require.NoError(t, c.UpdatePositionsInCommittee(r, s)) for key, indices := range tt.currentSyncMap { - pos, err := cache.CurrentPeriodIndexPosition(r, key) + pos, err := c.CurrentPeriodIndexPosition(r, key) require.NoError(t, err) require.DeepEqual(t, indices, pos) } for key, indices := range tt.nextSyncMap { - pos, err := cache.NextPeriodIndexPosition(r, key) + pos, err := c.NextPeriodIndexPosition(r, key) require.NoError(t, err) require.DeepEqual(t, indices, pos) } diff --git a/beacon-chain/core/altair/attestation.go b/beacon-chain/core/altair/attestation.go index cf6c109156..d54c6f4728 100644 --- a/beacon-chain/core/altair/attestation.go +++ b/beacon-chain/core/altair/attestation.go @@ -34,8 +34,8 @@ func ProcessAttestationsNoVerifySignature( if err != nil { return nil, err } - for idx, attestation := range body.Attestations() { - beaconState, err = ProcessAttestationNoVerifySignature(ctx, beaconState, attestation, totalBalance) + for idx, att := range body.Attestations() { + beaconState, err = ProcessAttestationNoVerifySignature(ctx, beaconState, att, totalBalance) if err != nil { return nil, errors.Wrapf(err, "could not verify attestation at index %d in block", idx) } diff --git a/beacon-chain/core/altair/attestation_test.go b/beacon-chain/core/altair/attestation_test.go index 650db46c9f..813497e965 100644 --- a/beacon-chain/core/altair/attestation_test.go +++ b/beacon-chain/core/altair/attestation_test.go @@ -411,21 +411,21 @@ func TestValidatorFlag_Add_ExceedsLength(t *testing.T) { func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) { fuzzer := fuzz.NewWithSeed(0) - state := ðpb.BeaconStateAltair{} + st := ðpb.BeaconStateAltair{} b := ðpb.SignedBeaconBlockAltair{Block: ðpb.BeaconBlockAltair{}} for i := 0; i < 10000; i++ { - fuzzer.Fuzz(state) + fuzzer.Fuzz(st) fuzzer.Fuzz(b) if b.Block == nil { b.Block = ðpb.BeaconBlockAltair{} } - s, err := stateAltair.InitializeFromProtoUnsafe(state) + s, err := stateAltair.InitializeFromProtoUnsafe(st) require.NoError(t, err) wsb, err := wrapper.WrappedSignedBeaconBlock(b) require.NoError(t, err) r, err := altair.ProcessAttestationsNoVerifySignature(context.Background(), s, wsb) if err != nil && r != nil { - t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b) + t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, s, b) } } } diff --git a/beacon-chain/core/altair/deposit.go b/beacon-chain/core/altair/deposit.go index 73eaf81c91..1f58533762 100644 --- a/beacon-chain/core/altair/deposit.go +++ b/beacon-chain/core/altair/deposit.go @@ -25,7 +25,7 @@ func ProcessDeposits( if deposit == nil || deposit.Data == nil { return nil, errors.New("got a nil deposit in block") } - beaconState, err = ProcessDeposit(ctx, beaconState, deposit, batchVerified) + beaconState, err = ProcessDeposit(beaconState, deposit, batchVerified) if err != nil { return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey)) } @@ -34,7 +34,7 @@ func ProcessDeposits( } // ProcessDeposit processes validator deposit for beacon state Altair. -func ProcessDeposit(ctx context.Context, beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) { +func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) { beaconState, isNewValidator, err := blocks.ProcessDeposit(beaconState, deposit, verifySignature) if err != nil { return nil, err diff --git a/beacon-chain/core/altair/deposit_fuzz_test.go b/beacon-chain/core/altair/deposit_fuzz_test.go index c440d8ae2f..99eda4c406 100644 --- a/beacon-chain/core/altair/deposit_fuzz_test.go +++ b/beacon-chain/core/altair/deposit_fuzz_test.go @@ -40,7 +40,7 @@ func TestFuzzProcessDeposit_10000(t *testing.T) { fuzzer.Fuzz(deposit) s, err := stateAltair.InitializeFromProtoUnsafe(state) require.NoError(t, err) - r, err := altair.ProcessDeposit(context.Background(), s, deposit, true) + r, err := altair.ProcessDeposit(s, deposit, true) if err != nil && r != nil { t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit) } diff --git a/beacon-chain/core/altair/deposit_test.go b/beacon-chain/core/altair/deposit_test.go index 4a1a87f5a3..83afd1c19c 100644 --- a/beacon-chain/core/altair/deposit_test.go +++ b/beacon-chain/core/altair/deposit_test.go @@ -183,7 +183,7 @@ func TestProcessDeposit_AddsNewValidatorDeposit(t *testing.T) { }, }) require.NoError(t, err) - newState, err := altair.ProcessDeposit(context.Background(), beaconState, dep[0], true) + newState, err := altair.ProcessDeposit(beaconState, dep[0], true) require.NoError(t, err, "Process deposit failed") require.Equal(t, 2, len(newState.Validators()), "Expected validator list to have length 2") require.Equal(t, 2, len(newState.Balances()), "Expected validator balances list to have length 2") @@ -201,9 +201,9 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) { dep, _, err := util.DeterministicDepositsAndKeys(1) require.NoError(t, err) dep[0].Data.Signature = make([]byte, 96) - trie, _, err := util.DepositTrieFromDeposits(dep) + dt, _, err := util.DepositTrieFromDeposits(dep) require.NoError(t, err) - root, err := trie.HashTreeRoot() + root, err := dt.HashTreeRoot() require.NoError(t, err) eth1Data := ðpb.Eth1Data{ DepositRoot: root[:], @@ -226,7 +226,7 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) { }, }) require.NoError(t, err) - newState, err := altair.ProcessDeposit(context.Background(), beaconState, dep[0], true) + newState, err := altair.ProcessDeposit(beaconState, dep[0], true) require.NoError(t, err, "Expected invalid block deposit to be ignored without error") if newState.Eth1DepositIndex() != 1 { diff --git a/beacon-chain/core/altair/sync_committee_test.go b/beacon-chain/core/altair/sync_committee_test.go index a2ad594836..c89fe4f111 100644 --- a/beacon-chain/core/altair/sync_committee_test.go +++ b/beacon-chain/core/altair/sync_committee_test.go @@ -28,12 +28,12 @@ func TestSyncCommitteeIndices_CanGet(t *testing.T) { EffectiveBalance: params.BeaconConfig().MinDepositAmount, } } - state, err := stateAltair.InitializeFromProto(ðpb.BeaconStateAltair{ + st, err := stateAltair.InitializeFromProto(ðpb.BeaconStateAltair{ Validators: validators, RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector), }) require.NoError(t, err) - return state + return st } type args struct { @@ -103,27 +103,27 @@ func TestSyncCommitteeIndices_DifferentPeriods(t *testing.T) { EffectiveBalance: params.BeaconConfig().MinDepositAmount, } } - state, err := stateAltair.InitializeFromProto(ðpb.BeaconStateAltair{ + st, err := stateAltair.InitializeFromProto(ðpb.BeaconStateAltair{ Validators: validators, RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector), }) require.NoError(t, err) - return state + return st } - state := getState(t, params.BeaconConfig().MaxValidatorsPerCommittee) - got1, err := altair.NextSyncCommitteeIndices(context.Background(), state) + st := getState(t, params.BeaconConfig().MaxValidatorsPerCommittee) + got1, err := altair.NextSyncCommitteeIndices(context.Background(), st) require.NoError(t, err) - require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch)) - got2, err := altair.NextSyncCommitteeIndices(context.Background(), state) + require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch)) + got2, err := altair.NextSyncCommitteeIndices(context.Background(), st) require.NoError(t, err) require.DeepNotEqual(t, got1, got2) - require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch*types.Slot(params.BeaconConfig().EpochsPerSyncCommitteePeriod))) - got2, err = altair.NextSyncCommitteeIndices(context.Background(), state) + require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch*types.Slot(params.BeaconConfig().EpochsPerSyncCommitteePeriod))) + got2, err = altair.NextSyncCommitteeIndices(context.Background(), st) require.NoError(t, err) require.DeepNotEqual(t, got1, got2) - require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch*types.Slot(2*params.BeaconConfig().EpochsPerSyncCommitteePeriod))) - got2, err = altair.NextSyncCommitteeIndices(context.Background(), state) + require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch*types.Slot(2*params.BeaconConfig().EpochsPerSyncCommitteePeriod))) + got2, err = altair.NextSyncCommitteeIndices(context.Background(), st) require.NoError(t, err) require.DeepNotEqual(t, got1, got2) } @@ -140,12 +140,12 @@ func TestSyncCommittee_CanGet(t *testing.T) { PublicKey: blsKey.PublicKey().Marshal(), } } - state, err := stateAltair.InitializeFromProto(ðpb.BeaconStateAltair{ + st, err := stateAltair.InitializeFromProto(ðpb.BeaconStateAltair{ Validators: validators, RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector), }) require.NoError(t, err) - return state + return st } type args struct { @@ -260,8 +260,8 @@ func TestValidateNilSyncContribution(t *testing.T) { func TestSyncSubCommitteePubkeys_CanGet(t *testing.T) { helpers.ClearCache() - state := getState(t, params.BeaconConfig().MaxValidatorsPerCommittee) - com, err := altair.NextSyncCommittee(context.Background(), state) + st := getState(t, params.BeaconConfig().MaxValidatorsPerCommittee) + com, err := altair.NextSyncCommittee(context.Background(), st) require.NoError(t, err) sub, err := altair.SyncSubCommitteePubkeys(com, 0) require.NoError(t, err) @@ -395,10 +395,10 @@ func getState(t *testing.T, count uint64) state.BeaconState { PublicKey: blsKey.PublicKey().Marshal(), } } - state, err := stateAltair.InitializeFromProto(ðpb.BeaconStateAltair{ + st, err := stateAltair.InitializeFromProto(ðpb.BeaconStateAltair{ Validators: validators, RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector), }) require.NoError(t, err) - return state + return st } diff --git a/beacon-chain/core/blocks/attestation.go b/beacon-chain/core/blocks/attestation.go index bcc0ee0d32..0319959271 100644 --- a/beacon-chain/core/blocks/attestation.go +++ b/beacon-chain/core/blocks/attestation.go @@ -31,8 +31,8 @@ func ProcessAttestationsNoVerifySignature( } body := b.Block().Body() var err error - for idx, attestation := range body.Attestations() { - beaconState, err = ProcessAttestationNoVerifySignature(ctx, beaconState, attestation) + for idx, att := range body.Attestations() { + beaconState, err = ProcessAttestationNoVerifySignature(ctx, beaconState, att) if err != nil { return nil, errors.Wrapf(err, "could not verify attestation at index %d in block", idx) } diff --git a/beacon-chain/core/blocks/deposit.go b/beacon-chain/core/blocks/deposit.go index ceb7684bc0..4ca7f68ddf 100644 --- a/beacon-chain/core/blocks/deposit.go +++ b/beacon-chain/core/blocks/deposit.go @@ -37,8 +37,8 @@ func ProcessPreGenesisDeposits( // ActivateValidatorWithEffectiveBalance updates validator's effective balance, and if it's above MaxEffectiveBalance, validator becomes active in genesis. func ActivateValidatorWithEffectiveBalance(beaconState state.BeaconState, deposits []*ethpb.Deposit) (state.BeaconState, error) { - for _, deposit := range deposits { - pubkey := deposit.Data.PublicKey + for _, d := range deposits { + pubkey := d.Data.PublicKey index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubkey)) // In the event of the pubkey not existing, we continue processing the other // deposits. @@ -85,13 +85,13 @@ func ProcessDeposits( return nil, err } - for _, deposit := range deposits { - if deposit == nil || deposit.Data == nil { + for _, d := range deposits { + if d == nil || d.Data == nil { return nil, errors.New("got a nil deposit in block") } - beaconState, _, err = ProcessDeposit(beaconState, deposit, batchVerified) + beaconState, _, err = ProcessDeposit(beaconState, d, batchVerified) if err != nil { - return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey)) + return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(d.Data.PublicKey)) } } return beaconState, nil diff --git a/beacon-chain/core/blocks/deposit_test.go b/beacon-chain/core/blocks/deposit_test.go index d04cc3921d..0ec8c45418 100644 --- a/beacon-chain/core/blocks/deposit_test.go +++ b/beacon-chain/core/blocks/deposit_test.go @@ -232,9 +232,9 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) { dep, _, err := util.DeterministicDepositsAndKeys(1) require.NoError(t, err) dep[0].Data.Signature = make([]byte, 96) - trie, _, err := util.DepositTrieFromDeposits(dep) + dt, _, err := util.DepositTrieFromDeposits(dep) require.NoError(t, err) - root, err := trie.HashTreeRoot() + root, err := dt.HashTreeRoot() require.NoError(t, err) eth1Data := ðpb.Eth1Data{ DepositRoot: root[:], @@ -283,15 +283,15 @@ func TestPreGenesisDeposits_SkipInvalidDeposit(t *testing.T) { dep, _, err := util.DeterministicDepositsAndKeys(100) require.NoError(t, err) dep[0].Data.Signature = make([]byte, 96) - trie, _, err := util.DepositTrieFromDeposits(dep) + dt, _, err := util.DepositTrieFromDeposits(dep) require.NoError(t, err) for i := range dep { - proof, err := trie.MerkleProof(i) + proof, err := dt.MerkleProof(i) require.NoError(t, err) dep[i].Proof = proof } - root, err := trie.HashTreeRoot() + root, err := dt.HashTreeRoot() require.NoError(t, err) eth1Data := ðpb.Eth1Data{ diff --git a/beacon-chain/core/execution/upgrade.go b/beacon-chain/core/execution/upgrade.go index 77e8a76d47..c77eeaf1ca 100644 --- a/beacon-chain/core/execution/upgrade.go +++ b/beacon-chain/core/execution/upgrade.go @@ -1,8 +1,6 @@ package execution import ( - "context" - "github.com/prysmaticlabs/prysm/beacon-chain/core/time" "github.com/prysmaticlabs/prysm/beacon-chain/state" v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3" @@ -13,7 +11,7 @@ import ( // UpgradeToBellatrix updates inputs a generic state to return the version Bellatrix state. // It inserts an empty `ExecutionPayloadHeader` into the state. -func UpgradeToBellatrix(ctx context.Context, state state.BeaconState) (state.BeaconState, error) { +func UpgradeToBellatrix(state state.BeaconState) (state.BeaconState, error) { epoch := time.CurrentEpoch(state) currentSyncCommittee, err := state.CurrentSyncCommittee() diff --git a/beacon-chain/core/execution/upgrade_test.go b/beacon-chain/core/execution/upgrade_test.go index 0e1984ba25..169e661a22 100644 --- a/beacon-chain/core/execution/upgrade_test.go +++ b/beacon-chain/core/execution/upgrade_test.go @@ -1,7 +1,6 @@ package execution_test import ( - "context" "testing" "github.com/prysmaticlabs/prysm/beacon-chain/core/execution" @@ -16,7 +15,7 @@ import ( func TestUpgradeToBellatrix(t *testing.T) { st, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee) preForkState := st.Copy() - mSt, err := execution.UpgradeToBellatrix(context.Background(), st) + mSt, err := execution.UpgradeToBellatrix(st) require.NoError(t, err) require.Equal(t, preForkState.GenesisTime(), mSt.GenesisTime()) diff --git a/beacon-chain/core/helpers/beacon_committee_test.go b/beacon-chain/core/helpers/beacon_committee_test.go index b1f9306e64..94e60ed71e 100644 --- a/beacon-chain/core/helpers/beacon_committee_test.go +++ b/beacon-chain/core/helpers/beacon_committee_test.go @@ -121,8 +121,8 @@ func TestCommitteeAssignments_NoProposerForSlot0(t *testing.T) { ClearCache() _, proposerIndexToSlots, err := CommitteeAssignments(context.Background(), state, 0) require.NoError(t, err, "Failed to determine CommitteeAssignments") - for _, slots := range proposerIndexToSlots { - for _, s := range slots { + for _, ss := range proposerIndexToSlots { + for _, s := range ss { assert.NotEqual(t, uint64(0), s, "No proposer should be assigned to slot 0") } } diff --git a/beacon-chain/core/helpers/shuffle.go b/beacon-chain/core/helpers/shuffle.go index 9ce07972b6..1c8d763146 100644 --- a/beacon-chain/core/helpers/shuffle.go +++ b/beacon-chain/core/helpers/shuffle.go @@ -96,8 +96,8 @@ func ComputeShuffledIndex(index types.ValidatorIndex, indexCount uint64, seed [3 copy(buf[:32], seed[:]) for { buf[seedSize] = round - hash := hashfunc(buf[:pivotViewSize]) - hash8 := hash[:8] + h := hashfunc(buf[:pivotViewSize]) + hash8 := h[:8] hash8Int := bytesutil.FromBytes8(hash8) pivot := hash8Int % indexCount flip := (pivot + indexCount - uint64(index)) % indexCount diff --git a/beacon-chain/core/signing/signing_root_test.go b/beacon-chain/core/signing/signing_root_test.go index 6374dc89ef..2be7f25eed 100644 --- a/beacon-chain/core/signing/signing_root_test.go +++ b/beacon-chain/core/signing/signing_root_test.go @@ -112,7 +112,7 @@ func TestSigningRoot_ComputeForkDigest(t *testing.T) { func TestFuzzverifySigningRoot_10000(_ *testing.T) { fuzzer := fuzz.NewWithSeed(0) - state := ðpb.BeaconState{} + st := ðpb.BeaconState{} pubkey := [fieldparams.BLSPubkeyLength]byte{} sig := [96]byte{} domain := [4]byte{} @@ -120,17 +120,17 @@ func TestFuzzverifySigningRoot_10000(_ *testing.T) { var s []byte var d []byte for i := 0; i < 10000; i++ { - fuzzer.Fuzz(state) + fuzzer.Fuzz(st) fuzzer.Fuzz(&pubkey) fuzzer.Fuzz(&sig) fuzzer.Fuzz(&domain) - fuzzer.Fuzz(state) + fuzzer.Fuzz(st) fuzzer.Fuzz(&p) fuzzer.Fuzz(&s) fuzzer.Fuzz(&d) - err := signing.VerifySigningRoot(state, pubkey[:], sig[:], domain[:]) + err := signing.VerifySigningRoot(st, pubkey[:], sig[:], domain[:]) _ = err - err = signing.VerifySigningRoot(state, p, s, d) + err = signing.VerifySigningRoot(st, p, s, d) _ = err } } diff --git a/beacon-chain/core/time/slot_epoch_test.go b/beacon-chain/core/time/slot_epoch_test.go index d5cd667609..39833026cb 100644 --- a/beacon-chain/core/time/slot_epoch_test.go +++ b/beacon-chain/core/time/slot_epoch_test.go @@ -43,9 +43,9 @@ func TestCurrentEpoch_OK(t *testing.T) { {slot: 200, epoch: 6}, } for _, tt := range tests { - state, err := v1.InitializeFromProto(ð.BeaconState{Slot: tt.slot}) + st, err := v1.InitializeFromProto(ð.BeaconState{Slot: tt.slot}) require.NoError(t, err) - assert.Equal(t, tt.epoch, time.CurrentEpoch(state), "ActiveCurrentEpoch(%d)", state.Slot()) + assert.Equal(t, tt.epoch, time.CurrentEpoch(st), "ActiveCurrentEpoch(%d)", st.Slot()) } } @@ -59,9 +59,9 @@ func TestPrevEpoch_OK(t *testing.T) { {slot: 2 * params.BeaconConfig().SlotsPerEpoch, epoch: 1}, } for _, tt := range tests { - state, err := v1.InitializeFromProto(ð.BeaconState{Slot: tt.slot}) + st, err := v1.InitializeFromProto(ð.BeaconState{Slot: tt.slot}) require.NoError(t, err) - assert.Equal(t, tt.epoch, time.PrevEpoch(state), "ActivePrevEpoch(%d)", state.Slot()) + assert.Equal(t, tt.epoch, time.PrevEpoch(st), "ActivePrevEpoch(%d)", st.Slot()) } } @@ -77,9 +77,9 @@ func TestNextEpoch_OK(t *testing.T) { {slot: 200, epoch: types.Epoch(200/params.BeaconConfig().SlotsPerEpoch + 1)}, } for _, tt := range tests { - state, err := v1.InitializeFromProto(ð.BeaconState{Slot: tt.slot}) + st, err := v1.InitializeFromProto(ð.BeaconState{Slot: tt.slot}) require.NoError(t, err) - assert.Equal(t, tt.epoch, time.NextEpoch(state), "NextEpoch(%d)", state.Slot()) + assert.Equal(t, tt.epoch, time.NextEpoch(st), "NextEpoch(%d)", st.Slot()) } } diff --git a/beacon-chain/core/transition/state.go b/beacon-chain/core/transition/state.go index 11b293fb69..fb7ea91869 100644 --- a/beacon-chain/core/transition/state.go +++ b/beacon-chain/core/transition/state.go @@ -54,23 +54,23 @@ import ( // return state // This method differs from the spec so as to process deposits beforehand instead of the end of the function. func GenesisBeaconState(ctx context.Context, deposits []*ethpb.Deposit, genesisTime uint64, eth1Data *ethpb.Eth1Data) (state.BeaconState, error) { - state, err := EmptyGenesisState() + st, err := EmptyGenesisState() if err != nil { return nil, err } // Process initial deposits. - state, err = helpers.UpdateGenesisEth1Data(state, deposits, eth1Data) + st, err = helpers.UpdateGenesisEth1Data(st, deposits, eth1Data) if err != nil { return nil, err } - state, err = b.ProcessPreGenesisDeposits(ctx, state, deposits) + st, err = b.ProcessPreGenesisDeposits(ctx, st, deposits) if err != nil { return nil, errors.Wrap(err, "could not process validator deposits") } - return OptimizedGenesisBeaconState(genesisTime, state, state.Eth1Data()) + return OptimizedGenesisBeaconState(genesisTime, st, st.Eth1Data()) } // OptimizedGenesisBeaconState is used to create a state that has already processed deposits. This is to efficiently @@ -111,7 +111,7 @@ func OptimizedGenesisBeaconState(genesisTime uint64, preState state.BeaconState, return nil, errors.Wrapf(err, "could not hash tree root genesis validators %v", err) } - state := ðpb.BeaconState{ + st := ðpb.BeaconState{ // Misc fields. Slot: 0, GenesisTime: genesisTime, @@ -170,18 +170,18 @@ func OptimizedGenesisBeaconState(genesisTime uint64, preState state.BeaconState, return nil, errors.Wrap(err, "could not hash tree root empty block body") } - state.LatestBlockHeader = ðpb.BeaconBlockHeader{ + st.LatestBlockHeader = ðpb.BeaconBlockHeader{ ParentRoot: zeroHash, StateRoot: zeroHash, BodyRoot: bodyRoot[:], } - return v1.InitializeFromProto(state) + return v1.InitializeFromProto(st) } // EmptyGenesisState returns an empty beacon state object. func EmptyGenesisState() (state.BeaconState, error) { - state := ðpb.BeaconState{ + st := ðpb.BeaconState{ // Misc fields. Slot: 0, Fork: ðpb.Fork{ @@ -203,7 +203,7 @@ func EmptyGenesisState() (state.BeaconState, error) { Eth1DataVotes: []*ethpb.Eth1Data{}, Eth1DepositIndex: 0, } - return v1.InitializeFromProto(state) + return v1.InitializeFromProto(st) } // IsValidGenesisState gets called whenever there's a deposit event, diff --git a/beacon-chain/core/transition/transition.go b/beacon-chain/core/transition/transition.go index 7f6961f93f..520cf6d846 100644 --- a/beacon-chain/core/transition/transition.go +++ b/beacon-chain/core/transition/transition.go @@ -279,7 +279,7 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot types.Slot) } if time.CanUpgradeToBellatrix(state.Slot()) { - state, err = execution.UpgradeToBellatrix(ctx, state) + state, err = execution.UpgradeToBellatrix(state) if err != nil { tracing.AnnotateError(span, err) return nil, err diff --git a/beacon-chain/core/transition/transition_no_verify_sig.go b/beacon-chain/core/transition/transition_no_verify_sig.go index df68e3f7cb..e514e009fd 100644 --- a/beacon-chain/core/transition/transition_no_verify_sig.go +++ b/beacon-chain/core/transition/transition_no_verify_sig.go @@ -42,7 +42,7 @@ import ( // assert block.state_root == hash_tree_root(state) func ExecuteStateTransitionNoVerifyAnySig( ctx context.Context, - state state.BeaconState, + st state.BeaconState, signed interfaces.SignedBeaconBlock, ) (*bls.SignatureBatch, state.BeaconState, error) { if ctx.Err() != nil { @@ -57,21 +57,21 @@ func ExecuteStateTransitionNoVerifyAnySig( var err error interop.WriteBlockToDisk(signed, false /* Has the block failed */) - interop.WriteStateToDisk(state) + interop.WriteStateToDisk(st) - state, err = ProcessSlotsUsingNextSlotCache(ctx, state, signed.Block().ParentRoot(), signed.Block().Slot()) + st, err = ProcessSlotsUsingNextSlotCache(ctx, st, signed.Block().ParentRoot(), signed.Block().Slot()) if err != nil { return nil, nil, errors.Wrap(err, "could not process slots") } // Execute per block transition. - set, state, err := ProcessBlockNoVerifyAnySig(ctx, state, signed) + set, st, err := ProcessBlockNoVerifyAnySig(ctx, st, signed) if err != nil { return nil, nil, errors.Wrap(err, "could not process block") } // State root validation. - postStateRoot, err := state.HashTreeRoot(ctx) + postStateRoot, err := st.HashTreeRoot(ctx) if err != nil { return nil, nil, err } @@ -80,7 +80,7 @@ func ExecuteStateTransitionNoVerifyAnySig( postStateRoot[:], signed.Block().StateRoot()) } - return set, state, nil + return set, st, nil } // CalculateStateRoot defines the procedure for a state transition function. @@ -155,7 +155,7 @@ func CalculateStateRoot( // process_operations(state, block.body) func ProcessBlockNoVerifyAnySig( ctx context.Context, - state state.BeaconState, + st state.BeaconState, signed interfaces.SignedBeaconBlock, ) (*bls.SignatureBatch, state.BeaconState, error) { ctx, span := trace.StartSpan(ctx, "core.state.ProcessBlockNoVerifyAnySig") @@ -164,27 +164,27 @@ func ProcessBlockNoVerifyAnySig( return nil, nil, err } - if state.Version() != signed.Block().Version() { - return nil, nil, fmt.Errorf("state and block are different version. %d != %d", state.Version(), signed.Block().Version()) + if st.Version() != signed.Block().Version() { + return nil, nil, fmt.Errorf("state and block are different version. %d != %d", st.Version(), signed.Block().Version()) } blk := signed.Block() - state, err := ProcessBlockForStateRoot(ctx, state, signed) + st, err := ProcessBlockForStateRoot(ctx, st, signed) if err != nil { return nil, nil, err } - bSet, err := b.BlockSignatureBatch(state, blk.ProposerIndex(), signed.Signature(), blk.HashTreeRoot) + bSet, err := b.BlockSignatureBatch(st, blk.ProposerIndex(), signed.Signature(), blk.HashTreeRoot) if err != nil { tracing.AnnotateError(span, err) return nil, nil, errors.Wrap(err, "could not retrieve block signature set") } - rSet, err := b.RandaoSignatureBatch(ctx, state, signed.Block().Body().RandaoReveal()) + rSet, err := b.RandaoSignatureBatch(ctx, st, signed.Block().Body().RandaoReveal()) if err != nil { tracing.AnnotateError(span, err) return nil, nil, errors.Wrap(err, "could not retrieve randao signature set") } - aSet, err := b.AttestationSignatureBatch(ctx, state, signed.Block().Body().Attestations()) + aSet, err := b.AttestationSignatureBatch(ctx, st, signed.Block().Body().Attestations()) if err != nil { return nil, nil, errors.Wrap(err, "could not retrieve attestation signature set") } @@ -193,7 +193,7 @@ func ProcessBlockNoVerifyAnySig( set := bls.NewSet() set.Join(bSet).Join(rSet).Join(aSet) - return set, state, nil + return set, st, nil } // ProcessOperationsNoVerifyAttsSigs processes the operations in the beacon block and updates beacon state @@ -348,45 +348,45 @@ func ProcessBlockForStateRoot( // This calls altair block operations. func altairOperations( ctx context.Context, - state state.BeaconState, + st state.BeaconState, signedBeaconBlock interfaces.SignedBeaconBlock) (state.BeaconState, error) { - state, err := b.ProcessProposerSlashings(ctx, state, signedBeaconBlock.Block().Body().ProposerSlashings(), v.SlashValidator) + st, err := b.ProcessProposerSlashings(ctx, st, signedBeaconBlock.Block().Body().ProposerSlashings(), v.SlashValidator) if err != nil { return nil, errors.Wrap(err, "could not process altair proposer slashing") } - state, err = b.ProcessAttesterSlashings(ctx, state, signedBeaconBlock.Block().Body().AttesterSlashings(), v.SlashValidator) + st, err = b.ProcessAttesterSlashings(ctx, st, signedBeaconBlock.Block().Body().AttesterSlashings(), v.SlashValidator) if err != nil { return nil, errors.Wrap(err, "could not process altair attester slashing") } - state, err = altair.ProcessAttestationsNoVerifySignature(ctx, state, signedBeaconBlock) + st, err = altair.ProcessAttestationsNoVerifySignature(ctx, st, signedBeaconBlock) if err != nil { return nil, errors.Wrap(err, "could not process altair attestation") } - if _, err := altair.ProcessDeposits(ctx, state, signedBeaconBlock.Block().Body().Deposits()); err != nil { + if _, err := altair.ProcessDeposits(ctx, st, signedBeaconBlock.Block().Body().Deposits()); err != nil { return nil, errors.Wrap(err, "could not process altair deposit") } - return b.ProcessVoluntaryExits(ctx, state, signedBeaconBlock.Block().Body().VoluntaryExits()) + return b.ProcessVoluntaryExits(ctx, st, signedBeaconBlock.Block().Body().VoluntaryExits()) } // This calls phase 0 block operations. func phase0Operations( ctx context.Context, - state state.BeaconState, + st state.BeaconState, signedBeaconBlock interfaces.SignedBeaconBlock) (state.BeaconState, error) { - state, err := b.ProcessProposerSlashings(ctx, state, signedBeaconBlock.Block().Body().ProposerSlashings(), v.SlashValidator) + st, err := b.ProcessProposerSlashings(ctx, st, signedBeaconBlock.Block().Body().ProposerSlashings(), v.SlashValidator) if err != nil { return nil, errors.Wrap(err, "could not process block proposer slashings") } - state, err = b.ProcessAttesterSlashings(ctx, state, signedBeaconBlock.Block().Body().AttesterSlashings(), v.SlashValidator) + st, err = b.ProcessAttesterSlashings(ctx, st, signedBeaconBlock.Block().Body().AttesterSlashings(), v.SlashValidator) if err != nil { return nil, errors.Wrap(err, "could not process block attester slashings") } - state, err = b.ProcessAttestationsNoVerifySignature(ctx, state, signedBeaconBlock) + st, err = b.ProcessAttestationsNoVerifySignature(ctx, st, signedBeaconBlock) if err != nil { return nil, errors.Wrap(err, "could not process block attestations") } - if _, err := b.ProcessDeposits(ctx, state, signedBeaconBlock.Block().Body().Deposits()); err != nil { + if _, err := b.ProcessDeposits(ctx, st, signedBeaconBlock.Block().Body().Deposits()); err != nil { return nil, errors.Wrap(err, "could not process deposits") } - return b.ProcessVoluntaryExits(ctx, state, signedBeaconBlock.Block().Body().VoluntaryExits()) + return b.ProcessVoluntaryExits(ctx, st, signedBeaconBlock.Block().Body().VoluntaryExits()) } diff --git a/beacon-chain/db/kv/state.go b/beacon-chain/db/kv/state.go index 533349982b..1a1c30b17e 100644 --- a/beacon-chain/db/kv/state.go +++ b/beacon-chain/db/kv/state.go @@ -9,7 +9,7 @@ import ( "github.com/pkg/errors" "github.com/prysmaticlabs/prysm/beacon-chain/state" "github.com/prysmaticlabs/prysm/beacon-chain/state/genesis" - state_native "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native" + statenative "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native" v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1" v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2" v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3" @@ -224,7 +224,7 @@ func (s *Store) saveStatesEfficientInternal(ctx context.Context, tx *bolt.Tx, bl var pbState *ethpb.BeaconState var err error if features.Get().EnableNativeState { - pbState, err = state_native.ProtobufBeaconStatePhase0(rawType) + pbState, err = statenative.ProtobufBeaconStatePhase0(rawType) } else { pbState, err = v1.ProtobufBeaconState(rawType) } @@ -251,7 +251,7 @@ func (s *Store) saveStatesEfficientInternal(ctx context.Context, tx *bolt.Tx, bl var pbState *ethpb.BeaconStateAltair var err error if features.Get().EnableNativeState { - pbState, err = state_native.ProtobufBeaconStateAltair(rawType) + pbState, err = statenative.ProtobufBeaconStateAltair(rawType) } else { pbState, err = v2.ProtobufBeaconState(rawType) } @@ -279,7 +279,7 @@ func (s *Store) saveStatesEfficientInternal(ctx context.Context, tx *bolt.Tx, bl var pbState *ethpb.BeaconStateBellatrix var err error if features.Get().EnableNativeState { - pbState, err = state_native.ProtobufBeaconStateBellatrix(rawType) + pbState, err = statenative.ProtobufBeaconStateBellatrix(rawType) } else { pbState, err = v3.ProtobufBeaconState(rawType) } diff --git a/beacon-chain/forkchoice/doubly-linked-tree/forkchoice_test.go b/beacon-chain/forkchoice/doubly-linked-tree/forkchoice_test.go index 102e5ed24b..019421b489 100644 --- a/beacon-chain/forkchoice/doubly-linked-tree/forkchoice_test.go +++ b/beacon-chain/forkchoice/doubly-linked-tree/forkchoice_test.go @@ -64,15 +64,15 @@ func prepareForkchoiceState( func TestForkChoice_UpdateBalancesPositiveChange(t *testing.T) { f := setup(0, 0) ctx := context.Background() - state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) + st, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) f.votes = []Vote{ {indexToHash(1), indexToHash(1), 0}, @@ -92,15 +92,15 @@ func TestForkChoice_UpdateBalancesPositiveChange(t *testing.T) { func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) { f := setup(0, 0) ctx := context.Background() - state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) + st, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) s := f.store s.nodeByRoot[indexToHash(1)].balance = 100 s.nodeByRoot[indexToHash(2)].balance = 100 @@ -122,15 +122,15 @@ func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) { func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) { f := setup(0, 0) ctx := context.Background() - state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) + st, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) s := f.store s.nodeByRoot[indexToHash(1)].balance = 100 s.nodeByRoot[indexToHash(2)].balance = 100 @@ -152,24 +152,24 @@ func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) { func TestForkChoice_IsCanonical(t *testing.T) { f := setup(1, 1) ctx := context.Background() - state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) + st, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 4, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 4, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 5, indexToHash(5), indexToHash(4), params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 5, indexToHash(5), indexToHash(4), params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 6, indexToHash(6), indexToHash(5), params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 6, indexToHash(6), indexToHash(5), params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) require.Equal(t, true, f.IsCanonical(params.BeaconConfig().ZeroHash)) require.Equal(t, false, f.IsCanonical(indexToHash(1))) @@ -183,24 +183,24 @@ func TestForkChoice_IsCanonical(t *testing.T) { func TestForkChoice_IsCanonicalReorg(t *testing.T) { f := setup(1, 1) ctx := context.Background() - state, blkRoot, err := prepareForkchoiceState(ctx, 1, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) + st, blkRoot, err := prepareForkchoiceState(ctx, 1, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 2, [32]byte{'2'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 2, [32]byte{'2'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 3, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 3, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 4, [32]byte{'4'}, [32]byte{'2'}, params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 4, [32]byte{'4'}, [32]byte{'2'}, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 5, [32]byte{'5'}, [32]byte{'4'}, params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 5, [32]byte{'5'}, [32]byte{'4'}, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 6, [32]byte{'6'}, [32]byte{'5'}, params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 6, [32]byte{'6'}, [32]byte{'5'}, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) f.store.nodesLock.Lock() f.store.nodeByRoot[[32]byte{'3'}].balance = 10 @@ -231,15 +231,15 @@ func TestForkChoice_IsCanonicalReorg(t *testing.T) { func TestForkChoice_AncestorRoot(t *testing.T) { f := setup(1, 1) ctx := context.Background() - state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) + st, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 5, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 5, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) f.store.treeRootNode = f.store.nodeByRoot[indexToHash(1)] f.store.treeRootNode.parent = nil @@ -263,12 +263,12 @@ func TestForkChoice_AncestorRoot(t *testing.T) { func TestForkChoice_AncestorEqualSlot(t *testing.T) { f := setup(1, 1) ctx := context.Background() - state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) + st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) r, err := f.AncestorRoot(ctx, [32]byte{'3'}, 100) require.NoError(t, err) @@ -278,12 +278,12 @@ func TestForkChoice_AncestorEqualSlot(t *testing.T) { func TestForkChoice_AncestorLowerSlot(t *testing.T) { f := setup(1, 1) ctx := context.Background() - state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) + st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 200, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 200, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) r, err := f.AncestorRoot(ctx, [32]byte{'3'}, 150) require.NoError(t, err) @@ -294,20 +294,20 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) { ctx := context.Background() f := setup(1, 1) // Insert a block it will be head - state, blkRoot, err := prepareForkchoiceState(ctx, 1, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1) + st, blkRoot, err := prepareForkchoiceState(ctx, 1, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) head, err := f.Head(ctx, []uint64{}) require.NoError(t, err) require.Equal(t, [32]byte{'a'}, head) // Insert two extra blocks - state, blkRoot, err = prepareForkchoiceState(ctx, 2, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1) + st, blkRoot, err = prepareForkchoiceState(ctx, 2, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 3, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 3, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) head, err = f.Head(ctx, []uint64{}) require.NoError(t, err) require.Equal(t, [32]byte{'c'}, head) @@ -372,36 +372,36 @@ func TestStore_CommonAncestor(t *testing.T) { // \-- c -- f // \-- g // \ -- h -- i -- j - state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1) + st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 2, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 2, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 3, [32]byte{'d'}, [32]byte{'b'}, [32]byte{}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 3, [32]byte{'d'}, [32]byte{'b'}, [32]byte{}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 4, [32]byte{'e'}, [32]byte{'d'}, [32]byte{}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 4, [32]byte{'e'}, [32]byte{'d'}, [32]byte{}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 5, [32]byte{'f'}, [32]byte{'c'}, [32]byte{}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 5, [32]byte{'f'}, [32]byte{'c'}, [32]byte{}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 6, [32]byte{'g'}, [32]byte{'c'}, [32]byte{}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 6, [32]byte{'g'}, [32]byte{'c'}, [32]byte{}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 7, [32]byte{'h'}, [32]byte{'c'}, [32]byte{}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 7, [32]byte{'h'}, [32]byte{'c'}, [32]byte{}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 8, [32]byte{'i'}, [32]byte{'h'}, [32]byte{}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 8, [32]byte{'i'}, [32]byte{'h'}, [32]byte{}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 9, [32]byte{'j'}, [32]byte{'i'}, [32]byte{}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 9, [32]byte{'j'}, [32]byte{'i'}, [32]byte{}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) tests := []struct { name string @@ -480,18 +480,18 @@ func TestStore_CommonAncestor(t *testing.T) { // a -- b -- c -- d f = setup(0, 0) - state, blkRoot, err = prepareForkchoiceState(ctx, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1) + st, blkRoot, err = prepareForkchoiceState(ctx, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 2, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 2, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 3, [32]byte{'d'}, [32]byte{'c'}, [32]byte{}, 1, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 3, [32]byte{'d'}, [32]byte{'c'}, [32]byte{}, 1, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) tests = []struct { name string r1 [32]byte @@ -696,26 +696,26 @@ func TestForkChoice_UpdateCheckpoints(t *testing.T) { fcs.store.bestJustifiedCheckpoint = tt.bestJustified fcs.store.genesisTime = uint64(time.Now().Unix()) - uint64(tt.currentSlot)*params.BeaconConfig().SecondsPerSlot - state, blkRoot, err := prepareForkchoiceState(ctx, 32, [32]byte{'f'}, + st, blkRoot, err := prepareForkchoiceState(ctx, 32, [32]byte{'f'}, [32]byte{}, [32]byte{}, tt.finalized.Epoch, tt.finalized.Epoch) require.NoError(t, err) - require.NoError(t, fcs.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 64, [32]byte{'j'}, + require.NoError(t, fcs.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 64, [32]byte{'j'}, [32]byte{'f'}, [32]byte{}, tt.justified.Epoch, tt.finalized.Epoch) require.NoError(t, err) - require.NoError(t, fcs.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 96, [32]byte{'b'}, + require.NoError(t, fcs.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 96, [32]byte{'b'}, [32]byte{'j'}, [32]byte{}, tt.newJustified.Epoch, tt.newFinalized.Epoch) require.NoError(t, err) - require.NoError(t, fcs.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 96, [32]byte{'c'}, + require.NoError(t, fcs.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 96, [32]byte{'c'}, [32]byte{'f'}, [32]byte{}, tt.newJustified.Epoch, tt.newFinalized.Epoch) require.NoError(t, err) - require.NoError(t, fcs.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(ctx, 65, [32]byte{'h'}, + require.NoError(t, fcs.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(ctx, 65, [32]byte{'h'}, [32]byte{'f'}, [32]byte{}, tt.newFinalized.Epoch, tt.newFinalized.Epoch) require.NoError(t, err) - require.NoError(t, fcs.InsertNode(ctx, state, blkRoot)) + require.NoError(t, fcs.InsertNode(ctx, st, blkRoot)) // restart justifications cause insertion messed it up fcs.store.justifiedCheckpoint = tt.justified fcs.store.finalizedCheckpoint = tt.finalized diff --git a/beacon-chain/forkchoice/doubly-linked-tree/optimistic_sync_test.go b/beacon-chain/forkchoice/doubly-linked-tree/optimistic_sync_test.go index 9387b8fa62..4c320bbcfc 100644 --- a/beacon-chain/forkchoice/doubly-linked-tree/optimistic_sync_test.go +++ b/beacon-chain/forkchoice/doubly-linked-tree/optimistic_sync_test.go @@ -35,7 +35,7 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'b'}, [32]byte{'B'}, 12, - [][32]byte{[32]byte{'j'}}, + [][32]byte{{'j'}}, nil, }, { @@ -43,8 +43,8 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'b'}, [32]byte{'B'}, 4, - [][32]byte{[32]byte{'f'}, [32]byte{'e'}, [32]byte{'i'}, [32]byte{'h'}, [32]byte{'l'}, - [32]byte{'k'}, [32]byte{'g'}, [32]byte{'d'}, [32]byte{'c'}}, + [][32]byte{{'f'}, {'e'}, {'i'}, {'h'}, {'l'}, + {'k'}, {'g'}, {'d'}, {'c'}}, nil, }, { @@ -52,7 +52,7 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'h'}, [32]byte{'H'}, 12, - [][32]byte{[32]byte{'i'}}, + [][32]byte{{'i'}}, nil, }, { @@ -60,7 +60,7 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'g'}, [32]byte{'G'}, 11, - [][32]byte{[32]byte{'i'}, [32]byte{'h'}}, + [][32]byte{{'i'}, {'h'}}, nil, }, { @@ -68,7 +68,7 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'d'}, [32]byte{'D'}, 8, - [][32]byte{[32]byte{'i'}, [32]byte{'h'}, [32]byte{'l'}, [32]byte{'k'}, [32]byte{'g'}}, + [][32]byte{{'i'}, {'h'}, {'l'}, {'k'}, {'g'}}, nil, }, { @@ -76,7 +76,7 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'h'}, [32]byte{'D'}, 8, - [][32]byte{[32]byte{'i'}, [32]byte{'h'}, [32]byte{'l'}, [32]byte{'k'}, [32]byte{'g'}}, + [][32]byte{{'i'}, {'h'}, {'l'}, {'k'}, {'g'}}, nil, }, { @@ -84,7 +84,7 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'e'}, [32]byte{'D'}, 11, - [][32]byte{[32]byte{'f'}, [32]byte{'e'}}, + [][32]byte{{'f'}, {'e'}}, nil, }, { @@ -93,14 +93,14 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'C'}, 5, [][32]byte{ - [32]byte{'f'}, - [32]byte{'e'}, - [32]byte{'i'}, - [32]byte{'h'}, - [32]byte{'l'}, - [32]byte{'k'}, - [32]byte{'g'}, - [32]byte{'d'}, + {'f'}, + {'e'}, + {'i'}, + {'h'}, + {'l'}, + {'k'}, + {'g'}, + {'d'}, }, nil, }, @@ -109,7 +109,7 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'d'}, [32]byte{'E'}, 8, - [][32]byte{[32]byte{'i'}, [32]byte{'h'}, [32]byte{'l'}, [32]byte{'k'}, [32]byte{'g'}}, + [][32]byte{{'i'}, {'h'}, {'l'}, {'k'}, {'g'}}, nil, }, { @@ -117,7 +117,7 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'j'}, [32]byte{'B'}, 12, - [][32]byte{[32]byte{'j'}}, + [][32]byte{{'j'}}, nil, }, { @@ -141,7 +141,7 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'h'}, [32]byte{'D'}, 8, - [][32]byte{[32]byte{'i'}, [32]byte{'h'}, [32]byte{'l'}, [32]byte{'k'}, [32]byte{'g'}}, + [][32]byte{{'i'}, {'h'}, {'l'}, {'k'}, {'g'}}, nil, }, { @@ -149,7 +149,7 @@ func TestPruneInvalid(t *testing.T) { [32]byte{'h'}, [32]byte{'D'}, 8, - [][32]byte{[32]byte{'i'}, [32]byte{'h'}, [32]byte{'l'}, [32]byte{'k'}, [32]byte{'g'}}, + [][32]byte{{'i'}, {'h'}, {'l'}, {'k'}, {'g'}}, nil, }, } diff --git a/beacon-chain/forkchoice/protoarray/ffg_update_test.go b/beacon-chain/forkchoice/protoarray/ffg_update_test.go index 05c817ac5a..10e700fe6d 100644 --- a/beacon-chain/forkchoice/protoarray/ffg_update_test.go +++ b/beacon-chain/forkchoice/protoarray/ffg_update_test.go @@ -74,15 +74,15 @@ func TestFFGUpdates_OneBranch(t *testing.T) { // 2 <- justified: 1, finalized: 0 // | // 3 <- justified: 2, finalized: 1 - state, blkRoot, err := prepareForkchoiceState(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) + st, blkRoot, err := prepareForkchoiceState(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(context.Background(), 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(context.Background(), 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(context.Background(), 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 2, 1) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(context.Background(), 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 2, 1) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) // With starting justified epoch at 0, the head should be 3: // 0 <- start @@ -146,37 +146,37 @@ func TestFFGUpdates_TwoBranches(t *testing.T) { // | | // justified: 2, finalized: 0 -> 9 10 <- justified: 2, finalized: 0 // Left branch. - state, blkRoot, err := prepareForkchoiceState(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) + st, blkRoot, err := prepareForkchoiceState(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(context.Background(), 2, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(context.Background(), 2, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(context.Background(), 3, indexToHash(5), indexToHash(3), params.BeaconConfig().ZeroHash, 1, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(context.Background(), 3, indexToHash(5), indexToHash(3), params.BeaconConfig().ZeroHash, 1, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(7), indexToHash(5), params.BeaconConfig().ZeroHash, 1, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(7), indexToHash(5), params.BeaconConfig().ZeroHash, 1, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(9), indexToHash(7), params.BeaconConfig().ZeroHash, 2, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(9), indexToHash(7), params.BeaconConfig().ZeroHash, 2, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) // Right branch. - state, blkRoot, err = prepareForkchoiceState(context.Background(), 1, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) + st, blkRoot, err = prepareForkchoiceState(context.Background(), 1, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(context.Background(), 2, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(context.Background(), 2, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(context.Background(), 3, indexToHash(6), indexToHash(4), params.BeaconConfig().ZeroHash, 0, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(context.Background(), 3, indexToHash(6), indexToHash(4), params.BeaconConfig().ZeroHash, 0, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(8), indexToHash(6), params.BeaconConfig().ZeroHash, 1, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(8), indexToHash(6), params.BeaconConfig().ZeroHash, 1, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) - state, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(10), indexToHash(8), params.BeaconConfig().ZeroHash, 2, 0) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) + st, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(10), indexToHash(8), params.BeaconConfig().ZeroHash, 2, 0) require.NoError(t, err) - require.NoError(t, f.InsertNode(ctx, state, blkRoot)) + require.NoError(t, f.InsertNode(ctx, st, blkRoot)) // With start at 0, the head should be 10: // 0 <-- start diff --git a/beacon-chain/forkchoice/protoarray/optimistic_sync_test.go b/beacon-chain/forkchoice/protoarray/optimistic_sync_test.go index d96d95f0fe..7c40f2b816 100644 --- a/beacon-chain/forkchoice/protoarray/optimistic_sync_test.go +++ b/beacon-chain/forkchoice/protoarray/optimistic_sync_test.go @@ -227,7 +227,7 @@ func TestSetOptimisticToInvalid(t *testing.T) { 3, 12, 8, - [][32]byte{[32]byte{'j'}}, + [][32]byte{{'j'}}, }, { "Remove tip, parent was optimistic", @@ -237,7 +237,7 @@ func TestSetOptimisticToInvalid(t *testing.T) { NonExistentNode, NonExistentNode, 1, - [][32]byte{[32]byte{'i'}}, + [][32]byte{{'i'}}, }, { "Remove tip, lvh is inner and valid", @@ -247,7 +247,7 @@ func TestSetOptimisticToInvalid(t *testing.T) { 6, 8, 3, - [][32]byte{[32]byte{'g'}, [32]byte{'h'}, [32]byte{'k'}, [32]byte{'i'}, [32]byte{'l'}}, + [][32]byte{{'g'}, {'h'}, {'k'}, {'i'}, {'l'}}, }, { "Remove inner, lvh is inner and optimistic", @@ -257,7 +257,7 @@ func TestSetOptimisticToInvalid(t *testing.T) { 10, 12, 2, - [][32]byte{[32]byte{'h'}, [32]byte{'i'}}, + [][32]byte{{'h'}, {'i'}}, }, { "Remove tip, lvh is inner and optimistic", @@ -267,7 +267,7 @@ func TestSetOptimisticToInvalid(t *testing.T) { 9, 11, 2, - [][32]byte{[32]byte{'k'}, [32]byte{'l'}}, + [][32]byte{{'k'}, {'l'}}, }, { "Remove tip, lvh is not an ancestor", @@ -277,7 +277,7 @@ func TestSetOptimisticToInvalid(t *testing.T) { 5, 12, 7, - [][32]byte{[32]byte{'j'}}, + [][32]byte{{'j'}}, }, { "Remove inner, lvh is not an ancestor", @@ -287,7 +287,7 @@ func TestSetOptimisticToInvalid(t *testing.T) { NonExistentNode, NonExistentNode, 1, - [][32]byte{[32]byte{'g'}, [32]byte{'h'}, [32]byte{'k'}, [32]byte{'i'}, [32]byte{'l'}}, + [][32]byte{{'g'}, {'h'}, {'k'}, {'i'}, {'l'}}, }, { "Remove not inserted, parent was invalid", @@ -297,7 +297,7 @@ func TestSetOptimisticToInvalid(t *testing.T) { 3, 12, 8, - [][32]byte{[32]byte{'j'}}, + [][32]byte{{'j'}}, }, { "Remove not inserted, parent was valid", diff --git a/beacon-chain/forkchoice/protoarray/unrealized_justification_test.go b/beacon-chain/forkchoice/protoarray/unrealized_justification_test.go index 53e498bdba..db4367899f 100644 --- a/beacon-chain/forkchoice/protoarray/unrealized_justification_test.go +++ b/beacon-chain/forkchoice/protoarray/unrealized_justification_test.go @@ -1,9 +1,8 @@ package protoarray import ( - "testing" - "context" + "testing" forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types" "github.com/prysmaticlabs/prysm/config/params" diff --git a/beacon-chain/monitor/process_attestation.go b/beacon-chain/monitor/process_attestation.go index cbdde2d0fb..e4394c6ced 100644 --- a/beacon-chain/monitor/process_attestation.go +++ b/beacon-chain/monitor/process_attestation.go @@ -57,8 +57,8 @@ func (s *Service) processAttestations(ctx context.Context, state state.BeaconSta if blk == nil || blk.Body() == nil { return } - for _, attestation := range blk.Body().Attestations() { - s.processIncludedAttestation(ctx, state, attestation) + for _, att := range blk.Body().Attestations() { + s.processIncludedAttestation(ctx, state, att) } } @@ -165,13 +165,13 @@ func (s *Service) processUnaggregatedAttestation(ctx context.Context, att *ethpb s.RLock() defer s.RUnlock() root := bytesutil.ToBytes32(att.Data.BeaconBlockRoot) - state := s.config.StateGen.StateByRootIfCachedNoCopy(root) - if state == nil { + st := s.config.StateGen.StateByRootIfCachedNoCopy(root) + if st == nil { log.WithField("BeaconBlockRoot", fmt.Sprintf("%#x", bytesutil.Trunc(root[:]))).Debug( "Skipping unaggregated attestation due to state not found in cache") return } - attestingIndices, err := attestingIndices(ctx, state, att) + attestingIndices, err := attestingIndices(ctx, st, att) if err != nil { log.WithError(err).Error("Could not get attesting indices") return @@ -207,13 +207,13 @@ func (s *Service) processAggregatedAttestation(ctx context.Context, att *ethpb.A var root [32]byte copy(root[:], att.Aggregate.Data.BeaconBlockRoot) - state := s.config.StateGen.StateByRootIfCachedNoCopy(root) - if state == nil { + st := s.config.StateGen.StateByRootIfCachedNoCopy(root) + if st == nil { log.WithField("BeaconBlockRoot", fmt.Sprintf("%#x", bytesutil.Trunc(root[:]))).Debug( "Skipping aggregated attestation due to state not found in cache") return } - attestingIndices, err := attestingIndices(ctx, state, att.Aggregate) + attestingIndices, err := attestingIndices(ctx, st, att.Aggregate) if err != nil { log.WithError(err).Error("Could not get attesting indices") return diff --git a/beacon-chain/monitor/process_block.go b/beacon-chain/monitor/process_block.go index 87fc27efab..7c3b8d2e36 100644 --- a/beacon-chain/monitor/process_block.go +++ b/beacon-chain/monitor/process_block.go @@ -37,8 +37,8 @@ func (s *Service) processBlock(ctx context.Context, b interfaces.SignedBeaconBlo log.WithError(err).Error("Could not compute block's hash tree root") return } - state := s.config.StateGen.StateByRootIfCachedNoCopy(root) - if state == nil { + st := s.config.StateGen.StateByRootIfCachedNoCopy(root) + if st == nil { log.WithField("BeaconBlockRoot", fmt.Sprintf("%#x", bytesutil.Trunc(root[:]))).Debug( "Skipping block collection due to state not found in cache") return @@ -51,12 +51,12 @@ func (s *Service) processBlock(ctx context.Context, b interfaces.SignedBeaconBlo if currEpoch != lastSyncedEpoch && slots.SyncCommitteePeriod(currEpoch) == slots.SyncCommitteePeriod(lastSyncedEpoch) { - s.updateSyncCommitteeTrackedVals(state) + s.updateSyncCommitteeTrackedVals(st) } - s.processSyncAggregate(state, blk) - s.processProposedBlock(state, root, blk) - s.processAttestations(ctx, state, blk) + s.processSyncAggregate(st, blk) + s.processProposedBlock(st, root, blk) + s.processAttestations(ctx, st, blk) if blk.Slot()%(AggregateReportingPeriod*params.BeaconConfig().SlotsPerEpoch) == 0 { s.logAggregatedPerformance() diff --git a/beacon-chain/monitor/service.go b/beacon-chain/monitor/service.go index e279649999..9599a7e785 100644 --- a/beacon-chain/monitor/service.go +++ b/beacon-chain/monitor/service.go @@ -135,24 +135,24 @@ func (s *Service) run(stateChannel chan *feed.Event, stateSub event.Subscription log.WithError(err) return } - state, err := s.config.HeadFetcher.HeadState(s.ctx) + st, err := s.config.HeadFetcher.HeadState(s.ctx) if err != nil { log.WithError(err).Error("Could not get head state") return } - if state == nil { + if st == nil { log.Error("Head state is nil") return } - epoch := slots.ToEpoch(state.Slot()) + epoch := slots.ToEpoch(st.Slot()) log.WithField("Epoch", epoch).Info("Synced to head epoch, starting reporting performance") s.Lock() - s.initializePerformanceStructures(state, epoch) + s.initializePerformanceStructures(st, epoch) s.Unlock() - s.updateSyncCommitteeTrackedVals(state) + s.updateSyncCommitteeTrackedVals(st) s.Lock() s.isLogging = true @@ -200,9 +200,9 @@ func (s *Service) Stop() error { func (s *Service) waitForSync(stateChannel chan *feed.Event, stateSub event.Subscription) error { for { select { - case event := <-stateChannel: - if event.Type == statefeed.Synced { - _, ok := event.Data.(*statefeed.SyncedData) + case e := <-stateChannel: + if e.Type == statefeed.Synced { + _, ok := e.Data.(*statefeed.SyncedData) if !ok { return errNotSyncedData } @@ -231,9 +231,9 @@ func (s *Service) monitorRoutine(stateChannel chan *feed.Event, stateSub event.S for { select { - case event := <-stateChannel: - if event.Type == statefeed.BlockProcessed { - data, ok := event.Data.(*statefeed.BlockProcessedData) + case e := <-stateChannel: + if e.Type == statefeed.BlockProcessed { + data, ok := e.Data.(*statefeed.BlockProcessedData) if !ok { log.Error("Event feed data is not of type *statefeed.BlockProcessedData") } else if data.Verified { @@ -241,31 +241,31 @@ func (s *Service) monitorRoutine(stateChannel chan *feed.Event, stateSub event.S s.processBlock(s.ctx, data.SignedBlock) } } - case event := <-opChannel: - switch event.Type { + case e := <-opChannel: + switch e.Type { case operation.UnaggregatedAttReceived: - data, ok := event.Data.(*operation.UnAggregatedAttReceivedData) + data, ok := e.Data.(*operation.UnAggregatedAttReceivedData) if !ok { log.Error("Event feed data is not of type *operation.UnAggregatedAttReceivedData") } else { s.processUnaggregatedAttestation(s.ctx, data.Attestation) } case operation.AggregatedAttReceived: - data, ok := event.Data.(*operation.AggregatedAttReceivedData) + data, ok := e.Data.(*operation.AggregatedAttReceivedData) if !ok { log.Error("Event feed data is not of type *operation.AggregatedAttReceivedData") } else { s.processAggregatedAttestation(s.ctx, data.Attestation) } case operation.ExitReceived: - data, ok := event.Data.(*operation.ExitReceivedData) + data, ok := e.Data.(*operation.ExitReceivedData) if !ok { log.Error("Event feed data is not of type *operation.ExitReceivedData") } else { s.processExit(data.Exit) } case operation.SyncCommitteeContributionReceived: - data, ok := event.Data.(*operation.SyncCommitteeContributionReceivedData) + data, ok := e.Data.(*operation.SyncCommitteeContributionReceivedData) if !ok { log.Error("Event feed data is not of type *operation.SyncCommitteeContributionReceivedData") } else { diff --git a/beacon-chain/p2p/broadcaster_test.go b/beacon-chain/p2p/broadcaster_test.go index cdeff63f80..9a5c938d8e 100644 --- a/beacon-chain/p2p/broadcaster_test.go +++ b/beacon-chain/p2p/broadcaster_test.go @@ -346,11 +346,11 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) { time.Sleep(500 * time.Millisecond) // libp2p fails without this delay... - peers := p.pubsub.ListPeers(topic) - peers2 := p2.pubsub.ListPeers(topic) + nodePeers := p.pubsub.ListPeers(topic) + nodePeers2 := p2.pubsub.ListPeers(topic) - assert.Equal(t, 1, len(peers)) - assert.Equal(t, 1, len(peers2)) + assert.Equal(t, 1, len(nodePeers)) + assert.Equal(t, 1, len(nodePeers2)) // Async listen for the pubsub, must be before the broadcast. var wg sync.WaitGroup diff --git a/beacon-chain/p2p/discovery_test.go b/beacon-chain/p2p/discovery_test.go index f0b5be1a2f..0d1aa85c55 100644 --- a/beacon-chain/p2p/discovery_test.go +++ b/beacon-chain/p2p/discovery_test.go @@ -215,8 +215,8 @@ func TestStaticPeering_PeersAreAdded(t *testing.T) { }) } time.Sleep(4 * time.Second) - peers := s.host.Network().Peers() - assert.Equal(t, 5, len(peers), "Not all peers added to peerstore") + ps := s.host.Network().Peers() + assert.Equal(t, 5, len(ps), "Not all peers added to peerstore") require.NoError(t, s.Stop()) exitRoutine <- true } diff --git a/beacon-chain/p2p/message_id.go b/beacon-chain/p2p/message_id.go index 0d996b7351..6e95f6526c 100644 --- a/beacon-chain/p2p/message_id.go +++ b/beacon-chain/p2p/message_id.go @@ -1,7 +1,7 @@ package p2p import ( - pubsub_pb "github.com/libp2p/go-libp2p-pubsub/pb" + pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb" "github.com/prysmaticlabs/prysm/beacon-chain/p2p/encoder" "github.com/prysmaticlabs/prysm/config/params" types "github.com/prysmaticlabs/prysm/consensus-types/primitives" @@ -22,7 +22,7 @@ import ( // Otherwise, set `message-id` to the first 20 bytes of the `SHA256` hash of // the concatenation of `MESSAGE_DOMAIN_INVALID_SNAPPY` with the raw message data, // i.e. `SHA256(MESSAGE_DOMAIN_INVALID_SNAPPY + message.data)[:20]`. -func MsgID(genesisValidatorsRoot []byte, pmsg *pubsub_pb.Message) string { +func MsgID(genesisValidatorsRoot []byte, pmsg *pubsubpb.Message) string { if pmsg == nil || pmsg.Data == nil || pmsg.Topic == nil { // Impossible condition that should // never be hit. @@ -71,7 +71,7 @@ func MsgID(genesisValidatorsRoot []byte, pmsg *pubsub_pb.Message) string { // + message.topic + snappy_decompress(message.data))[:20]. Otherwise, set message-id to the first 20 bytes of the SHA256 hash of the concatenation // of the following data: MESSAGE_DOMAIN_INVALID_SNAPPY, the length of the topic byte string (encoded as little-endian uint64), // the topic byte string, and the raw message data: i.e. SHA256(MESSAGE_DOMAIN_INVALID_SNAPPY + uint_to_bytes(uint64(len(message.topic))) + message.topic + message.data)[:20]. -func postAltairMsgID(pmsg *pubsub_pb.Message, fEpoch types.Epoch) string { +func postAltairMsgID(pmsg *pubsubpb.Message, fEpoch types.Epoch) string { topic := *pmsg.Topic topicLen := len(topic) topicLenBytes := bytesutil.Uint64ToBytesLittleEndian(uint64(topicLen)) // topicLen cannot be negative diff --git a/beacon-chain/powchain/deposit_test.go b/beacon-chain/powchain/deposit_test.go index 604c66b0c6..0aa77f1ade 100644 --- a/beacon-chain/powchain/deposit_test.go +++ b/beacon-chain/powchain/deposit_test.go @@ -132,13 +132,13 @@ func TestProcessDeposit_InvalidPublicKey(t *testing.T) { leaf, err := deposits[0].Data.HashTreeRoot() require.NoError(t, err, "Could not hash deposit") - trie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth) + generatedTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth) require.NoError(t, err) - deposits[0].Proof, err = trie.MerkleProof(0) + deposits[0].Proof, err = generatedTrie.MerkleProof(0) require.NoError(t, err) - root, err := trie.HashTreeRoot() + root, err := generatedTrie.HashTreeRoot() require.NoError(t, err) eth1Data := ðpb.Eth1Data{ @@ -176,10 +176,10 @@ func TestProcessDeposit_InvalidSignature(t *testing.T) { leaf, err := deposits[0].Data.HashTreeRoot() require.NoError(t, err, "Could not hash deposit") - trie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth) + generatedTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth) require.NoError(t, err) - root, err := trie.HashTreeRoot() + root, err := generatedTrie.HashTreeRoot() require.NoError(t, err) eth1Data := ðpb.Eth1Data{ @@ -213,15 +213,15 @@ func TestProcessDeposit_UnableToVerify(t *testing.T) { sig := keys[0].Sign([]byte{'F', 'A', 'K', 'E'}) deposits[0].Data.Signature = sig.Marshal() - trie, _, err := util.DepositTrieFromDeposits(deposits) + generatedTrie, _, err := util.DepositTrieFromDeposits(deposits) require.NoError(t, err) - root, err := trie.HashTreeRoot() + root, err := generatedTrie.HashTreeRoot() require.NoError(t, err) eth1Data := ðpb.Eth1Data{ DepositCount: 1, DepositRoot: root[:], } - proof, err := trie.MerkleProof(0) + proof, err := generatedTrie.MerkleProof(0) require.NoError(t, err) deposits[0].Proof = proof err = web3Service.processDeposit(context.Background(), eth1Data, deposits[0]) @@ -266,15 +266,15 @@ func TestProcessDeposit_IncompleteDeposit(t *testing.T) { sig := priv.Sign(signedRoot[:]) deposit.Data.Signature = sig.Marshal() - trie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) + generatedTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) require.NoError(t, err) - root, err := trie.HashTreeRoot() + root, err := generatedTrie.HashTreeRoot() require.NoError(t, err) eth1Data := ðpb.Eth1Data{ DepositCount: 1, DepositRoot: root[:], } - proof, err := trie.MerkleProof(0) + proof, err := generatedTrie.MerkleProof(0) require.NoError(t, err) dataRoot, err := deposit.Data.HashTreeRoot() require.NoError(t, err) @@ -283,14 +283,14 @@ func TestProcessDeposit_IncompleteDeposit(t *testing.T) { factor := params.BeaconConfig().MaxEffectiveBalance / params.BeaconConfig().EffectiveBalanceIncrement // deposit till 31e9 for i := 0; i < int(factor-1); i++ { - assert.NoError(t, trie.Insert(dataRoot[:], i)) + assert.NoError(t, generatedTrie.Insert(dataRoot[:], i)) - trieRoot, err := trie.HashTreeRoot() + trieRoot, err := generatedTrie.HashTreeRoot() require.NoError(t, err) eth1Data.DepositRoot = trieRoot[:] eth1Data.DepositCount = uint64(i + 1) - deposit.Proof, err = trie.MerkleProof(i) + deposit.Proof, err = generatedTrie.MerkleProof(i) require.NoError(t, err) err = web3Service.processDeposit(context.Background(), eth1Data, deposit) require.NoError(t, err, fmt.Sprintf("Could not process deposit at %d", i)) diff --git a/beacon-chain/powchain/log_processing.go b/beacon-chain/powchain/log_processing.go index 5baa32bdf4..f9f66bc355 100644 --- a/beacon-chain/powchain/log_processing.go +++ b/beacon-chain/powchain/log_processing.go @@ -11,13 +11,13 @@ import ( "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" - gethTypes "github.com/ethereum/go-ethereum/core/types" + gethtypes "github.com/ethereum/go-ethereum/core/types" "github.com/pkg/errors" "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" coreState "github.com/prysmaticlabs/prysm/beacon-chain/core/transition" - state_native "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native" + statenative "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native" v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1" "github.com/prysmaticlabs/prysm/config/features" "github.com/prysmaticlabs/prysm/config/params" @@ -89,7 +89,7 @@ func (s *Service) ProcessETH1Block(ctx context.Context, blkNum *big.Int) error { // ProcessLog is the main method which handles the processing of all // logs from the deposit contract on the eth1 chain. -func (s *Service) ProcessLog(ctx context.Context, depositLog gethTypes.Log) error { +func (s *Service) ProcessLog(ctx context.Context, depositLog gethtypes.Log) error { s.processingLock.RLock() defer s.processingLock.RUnlock() // Process logs according to their event signature. @@ -109,7 +109,7 @@ func (s *Service) ProcessLog(ctx context.Context, depositLog gethTypes.Log) erro // ProcessDepositLog processes the log which had been received from // the eth1 chain by trying to ascertain which participant deposited // in the contract. -func (s *Service) ProcessDepositLog(ctx context.Context, depositLog gethTypes.Log) error { +func (s *Service) ProcessDepositLog(ctx context.Context, depositLog gethtypes.Log) error { pubkey, withdrawalCredentials, amount, signature, merkleTreeIndex, err := contracts.UnpackDepositLogData(depositLog.Data) if err != nil { return errors.Wrap(err, "Could not unpack log") @@ -286,7 +286,7 @@ func (s *Service) processPastLogs(ctx context.Context) error { currentBlockNum = deploymentBlock } // To store all blocks. - headersMap := make(map[uint64]*gethTypes.Header) + headersMap := make(map[uint64]*gethtypes.Header) rawLogCount, err := s.depositContractCaller.GetDepositCount(&bind.CallOpts{}) if err != nil { return err @@ -343,7 +343,7 @@ func (s *Service) processPastLogs(ctx context.Context) error { return nil } -func (s *Service) processBlockInBatch(ctx context.Context, currentBlockNum uint64, latestFollowHeight uint64, batchSize uint64, additiveFactor uint64, logCount uint64, headersMap map[uint64]*gethTypes.Header) (uint64, uint64, error) { +func (s *Service) processBlockInBatch(ctx context.Context, currentBlockNum uint64, latestFollowHeight uint64, batchSize uint64, additiveFactor uint64, logCount uint64, headersMap map[uint64]*gethtypes.Header) (uint64, uint64, error) { // Batch request the desired headers and store them in a // map for quick access. requestHeaders := func(startBlk uint64, endBlk uint64) error { @@ -490,11 +490,11 @@ func (s *Service) processChainStartFromBlockNum(ctx context.Context, blkNum *big return nil } -func (s *Service) processChainStartFromHeader(ctx context.Context, header *gethTypes.Header) { +func (s *Service) processChainStartFromHeader(ctx context.Context, header *gethtypes.Header) { s.processChainStartIfReady(ctx, header.Hash(), header.Number, header.Time) } -func (s *Service) checkHeaderRange(ctx context.Context, start, end uint64, headersMap map[uint64]*gethTypes.Header, +func (s *Service) checkHeaderRange(ctx context.Context, start, end uint64, headersMap map[uint64]*gethtypes.Header, requestHeaders func(uint64, uint64) error) error { for i := start; i <= end; i++ { if !s.chainStartData.Chainstarted { @@ -544,7 +544,7 @@ func (s *Service) savePowchainData(ctx context.Context) error { var pbState *ethpb.BeaconState var err error if features.Get().EnableNativeState { - pbState, err = state_native.ProtobufBeaconStatePhase0(s.preGenesisState.InnerStateUnsafe()) + pbState, err = statenative.ProtobufBeaconStatePhase0(s.preGenesisState.InnerStateUnsafe()) } else { pbState, err = v1.ProtobufBeaconState(s.preGenesisState.InnerStateUnsafe()) } diff --git a/beacon-chain/powchain/service_test.go b/beacon-chain/powchain/service_test.go index 10d2e430e1..c5a278c7eb 100644 --- a/beacon-chain/powchain/service_test.go +++ b/beacon-chain/powchain/service_test.go @@ -915,6 +915,6 @@ func (s *slowRPCClient) BatchCall(b []rpc.BatchElem) error { return nil } -func (s *slowRPCClient) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error { +func (s *slowRPCClient) CallContext(_ context.Context, _ interface{}, _ string, _ ...interface{}) error { panic("implement me") } diff --git a/beacon-chain/rpc/apimiddleware/custom_handlers.go b/beacon-chain/rpc/apimiddleware/custom_handlers.go index 8314054218..c246f334a3 100644 --- a/beacon-chain/rpc/apimiddleware/custom_handlers.go +++ b/beacon-chain/rpc/apimiddleware/custom_handlers.go @@ -65,7 +65,7 @@ func handleGetBeaconBlockSSZV2(m *apimiddleware.ApiProxyMiddleware, endpoint api } func handleSubmitBlockSSZ(m *apimiddleware.ApiProxyMiddleware, endpoint apimiddleware.Endpoint, w http.ResponseWriter, req *http.Request) (handled bool) { - return handlePostSSZ(m, endpoint, w, req, sszConfig{}) + return handlePostSSZ(m, endpoint, w, req) } func handleSubmitBlindedBlockSSZ( @@ -74,7 +74,7 @@ func handleSubmitBlindedBlockSSZ( w http.ResponseWriter, req *http.Request, ) (handled bool) { - return handlePostSSZ(m, endpoint, w, req, sszConfig{}) + return handlePostSSZ(m, endpoint, w, req) } func handleProduceBlockSSZ(m *apimiddleware.ApiProxyMiddleware, endpoint apimiddleware.Endpoint, w http.ResponseWriter, req *http.Request) (handled bool) { @@ -157,13 +157,7 @@ func handleGetSSZ( return true } -func handlePostSSZ( - m *apimiddleware.ApiProxyMiddleware, - endpoint apimiddleware.Endpoint, - w http.ResponseWriter, - req *http.Request, - config sszConfig, -) (handled bool) { +func handlePostSSZ(m *apimiddleware.ApiProxyMiddleware, endpoint apimiddleware.Endpoint, w http.ResponseWriter, req *http.Request) (handled bool) { if !sszPosted(req) { return false } diff --git a/beacon-chain/rpc/eth/validator/validator.go b/beacon-chain/rpc/eth/validator/validator.go index cbaab3d710..e09b04060b 100644 --- a/beacon-chain/rpc/eth/validator/validator.go +++ b/beacon-chain/rpc/eth/validator/validator.go @@ -158,14 +158,14 @@ func (vs *Server) GetProposerDuties(ctx context.Context, req *ethpbv1.ProposerDu } duties := make([]*ethpbv1.ProposerDuty, 0) - for index, slots := range proposals { + for index, ss := range proposals { val, err := s.ValidatorAtIndexReadOnly(index) if err != nil { return nil, status.Errorf(codes.Internal, "Could not get validator: %v", err) } pubkey48 := val.PublicKey() pubkey := pubkey48[:] - for _, s := range slots { + for _, s := range ss { duties = append(duties, ðpbv1.ProposerDuty{ Pubkey: pubkey, ValidatorIndex: index, diff --git a/beacon-chain/rpc/eth/validator/validator_test.go b/beacon-chain/rpc/eth/validator/validator_test.go index 169f00a196..3d77dd692a 100644 --- a/beacon-chain/rpc/eth/validator/validator_test.go +++ b/beacon-chain/rpc/eth/validator/validator_test.go @@ -26,7 +26,7 @@ import ( mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing" v1alpha1validator "github.com/prysmaticlabs/prysm/beacon-chain/rpc/prysm/v1alpha1/validator" "github.com/prysmaticlabs/prysm/beacon-chain/rpc/testutil" - beaconState "github.com/prysmaticlabs/prysm/beacon-chain/state" + "github.com/prysmaticlabs/prysm/beacon-chain/state" "github.com/prysmaticlabs/prysm/beacon-chain/state/stategen" mockSync "github.com/prysmaticlabs/prysm/beacon-chain/sync/initial-sync/testing" fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams" @@ -569,7 +569,7 @@ func TestGetSyncCommitteeDuties(t *testing.T) { } require.NoError(t, newSyncPeriodSt.SetNextSyncCommittee(nextCommittee)) - stateFetchFn := func(slot types.Slot) beaconState.BeaconState { + stateFetchFn := func(slot types.Slot) state.BeaconState { if slot < newSyncPeriodStartSlot { return st } else { diff --git a/beacon-chain/rpc/prysm/v1alpha1/node/server.go b/beacon-chain/rpc/prysm/v1alpha1/node/server.go index d7765d9b8a..95c00dad04 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/node/server.go +++ b/beacon-chain/rpc/prysm/v1alpha1/node/server.go @@ -222,7 +222,7 @@ func (ns *Server) ListPeers(ctx context.Context, _ *empty.Empty) (*ethpb.Peers, } // GetETH1ConnectionStatus gets data about the ETH1 endpoints. -func (ns *Server) GetETH1ConnectionStatus(ctx context.Context, _ *empty.Empty) (*ethpb.ETH1ConnectionStatus, error) { +func (ns *Server) GetETH1ConnectionStatus(_ context.Context, _ *empty.Empty) (*ethpb.ETH1ConnectionStatus, error) { var errStrs []string errs := ns.POWChainInfoFetcher.ETH1ConnectionErrors() // Extract string version of the errors. diff --git a/beacon-chain/rpc/prysm/v1alpha1/validator/assignments_test.go b/beacon-chain/rpc/prysm/v1alpha1/validator/assignments_test.go index 5566aeb68a..535b555b44 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/validator/assignments_test.go +++ b/beacon-chain/rpc/prysm/v1alpha1/validator/assignments_test.go @@ -238,7 +238,7 @@ func TestGetBellatrixDuties_SyncCommitteeOK(t *testing.T) { require.NoError(t, bs.SetSlot(params.BeaconConfig().SlotsPerEpoch*types.Slot(params.BeaconConfig().EpochsPerSyncCommitteePeriod)-1)) require.NoError(t, helpers.UpdateSyncCommitteeCache(bs)) - bs, err = execution.UpgradeToBellatrix(context.Background(), bs) + bs, err = execution.UpgradeToBellatrix(bs) require.NoError(t, err) pubkeysAs48ByteType := make([][fieldparams.BLSPubkeyLength]byte, len(pubKeys)) diff --git a/beacon-chain/rpc/prysm/v1alpha1/validator/attester_test.go b/beacon-chain/rpc/prysm/v1alpha1/validator/attester_test.go index d77265fe34..77ed0b5bbe 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/validator/attester_test.go +++ b/beacon-chain/rpc/prysm/v1alpha1/validator/attester_test.go @@ -555,21 +555,21 @@ func TestServer_SubscribeCommitteeSubnets_DifferentLengthSlots(t *testing.T) { OperationNotifier: (&mock.ChainService{}).OperationNotifier(), } - var slots []types.Slot + var ss []types.Slot var comIdxs []types.CommitteeIndex var isAggregator []bool for i := types.Slot(100); i < 200; i++ { - slots = append(slots, i) + ss = append(ss, i) comIdxs = append(comIdxs, types.CommitteeIndex(randGen.Int63n(64))) boolVal := randGen.Uint64()%2 == 0 isAggregator = append(isAggregator, boolVal) } - slots = append(slots, 321) + ss = append(ss, 321) _, err := attesterServer.SubscribeCommitteeSubnets(context.Background(), ðpb.CommitteeSubnetsSubscribeRequest{ - Slots: slots, + Slots: ss, CommitteeIds: comIdxs, IsAggregator: isAggregator, }) @@ -601,19 +601,19 @@ func TestServer_SubscribeCommitteeSubnets_MultipleSlots(t *testing.T) { OperationNotifier: (&mock.ChainService{}).OperationNotifier(), } - var slots []types.Slot + var ss []types.Slot var comIdxs []types.CommitteeIndex var isAggregator []bool for i := types.Slot(100); i < 200; i++ { - slots = append(slots, i) + ss = append(ss, i) comIdxs = append(comIdxs, types.CommitteeIndex(randGen.Int63n(64))) boolVal := randGen.Uint64()%2 == 0 isAggregator = append(isAggregator, boolVal) } _, err = attesterServer.SubscribeCommitteeSubnets(context.Background(), ðpb.CommitteeSubnetsSubscribeRequest{ - Slots: slots, + Slots: ss, CommitteeIds: comIdxs, IsAggregator: isAggregator, }) diff --git a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_eth1data.go b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_eth1data.go index 6cc0752b39..a741c0b7da 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_eth1data.go +++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_eth1data.go @@ -63,13 +63,13 @@ func (vs *Server) eth1DataMajorityVote(ctx context.Context, beaconState state.Be } if lastBlockDepositCount >= vs.HeadFetcher.HeadETH1Data().DepositCount { - hash, err := vs.Eth1BlockFetcher.BlockHashByHeight(ctx, lastBlockByLatestValidTime.Number) + h, err := vs.Eth1BlockFetcher.BlockHashByHeight(ctx, lastBlockByLatestValidTime.Number) if err != nil { log.WithError(err).Error("Could not get hash of last block by latest valid time") return vs.randomETH1DataVote(ctx) } return ðpb.Eth1Data{ - BlockHash: hash.Bytes(), + BlockHash: h.Bytes(), DepositCount: lastBlockDepositCount, DepositRoot: lastBlockDepositRoot[:], }, nil diff --git a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go index bcd172bd92..f68a3450cd 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go +++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go @@ -1040,10 +1040,10 @@ func TestProposer_DepositTrie_UtilizesCachedFinalizedDeposits(t *testing.T) { HeadFetcher: &mock.ChainService{State: beaconState, Root: blkRoot[:]}, } - trie, err := bs.depositTrie(ctx, ðpb.Eth1Data{}, big.NewInt(int64(params.BeaconConfig().Eth1FollowDistance))) + dt, err := bs.depositTrie(ctx, ðpb.Eth1Data{}, big.NewInt(int64(params.BeaconConfig().Eth1FollowDistance))) require.NoError(t, err) - actualRoot, err := trie.HashTreeRoot() + actualRoot, err := dt.HashTreeRoot() require.NoError(t, err) expectedRoot, err := depositTrie.HashTreeRoot() require.NoError(t, err) @@ -1168,12 +1168,12 @@ func TestProposer_DepositTrie_RebuildTrie(t *testing.T) { HeadFetcher: &mock.ChainService{State: beaconState, Root: blkRoot[:]}, } - trie, err := bs.depositTrie(ctx, ðpb.Eth1Data{}, big.NewInt(int64(params.BeaconConfig().Eth1FollowDistance))) + dt, err := bs.depositTrie(ctx, ðpb.Eth1Data{}, big.NewInt(int64(params.BeaconConfig().Eth1FollowDistance))) require.NoError(t, err) expectedRoot, err := depositTrie.HashTreeRoot() require.NoError(t, err) - actualRoot, err := trie.HashTreeRoot() + actualRoot, err := dt.HashTreeRoot() require.NoError(t, err) assert.Equal(t, expectedRoot, actualRoot, "Incorrect deposit trie root") @@ -1192,51 +1192,51 @@ func TestProposer_ValidateDepositTrie(t *testing.T) { return ðpb.Eth1Data{DepositRoot: []byte{}, DepositCount: 10, BlockHash: []byte{}} }, trieCreator: func() *trie.SparseMerkleTrie { - trie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) + newTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) assert.NoError(t, err) - return trie + return newTrie }, success: false, }, { name: "invalid deposit root", eth1dataCreator: func() *ethpb.Eth1Data { - trie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) + newTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) assert.NoError(t, err) - assert.NoError(t, trie.Insert([]byte{'a'}, 0)) - assert.NoError(t, trie.Insert([]byte{'b'}, 1)) - assert.NoError(t, trie.Insert([]byte{'c'}, 2)) + assert.NoError(t, newTrie.Insert([]byte{'a'}, 0)) + assert.NoError(t, newTrie.Insert([]byte{'b'}, 1)) + assert.NoError(t, newTrie.Insert([]byte{'c'}, 2)) return ðpb.Eth1Data{DepositRoot: []byte{'B'}, DepositCount: 3, BlockHash: []byte{}} }, trieCreator: func() *trie.SparseMerkleTrie { - trie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) + newTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) assert.NoError(t, err) - assert.NoError(t, trie.Insert([]byte{'a'}, 0)) - assert.NoError(t, trie.Insert([]byte{'b'}, 1)) - assert.NoError(t, trie.Insert([]byte{'c'}, 2)) - return trie + assert.NoError(t, newTrie.Insert([]byte{'a'}, 0)) + assert.NoError(t, newTrie.Insert([]byte{'b'}, 1)) + assert.NoError(t, newTrie.Insert([]byte{'c'}, 2)) + return newTrie }, success: false, }, { name: "valid deposit trie", eth1dataCreator: func() *ethpb.Eth1Data { - trie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) + newTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) assert.NoError(t, err) - assert.NoError(t, trie.Insert([]byte{'a'}, 0)) - assert.NoError(t, trie.Insert([]byte{'b'}, 1)) - assert.NoError(t, trie.Insert([]byte{'c'}, 2)) - rt, err := trie.HashTreeRoot() + assert.NoError(t, newTrie.Insert([]byte{'a'}, 0)) + assert.NoError(t, newTrie.Insert([]byte{'b'}, 1)) + assert.NoError(t, newTrie.Insert([]byte{'c'}, 2)) + rt, err := newTrie.HashTreeRoot() require.NoError(t, err) return ðpb.Eth1Data{DepositRoot: rt[:], DepositCount: 3, BlockHash: []byte{}} }, trieCreator: func() *trie.SparseMerkleTrie { - trie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) + newTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) assert.NoError(t, err) - assert.NoError(t, trie.Insert([]byte{'a'}, 0)) - assert.NoError(t, trie.Insert([]byte{'b'}, 1)) - assert.NoError(t, trie.Insert([]byte{'c'}, 2)) - return trie + assert.NoError(t, newTrie.Insert([]byte{'a'}, 0)) + assert.NoError(t, newTrie.Insert([]byte{'b'}, 1)) + assert.NoError(t, newTrie.Insert([]byte{'c'}, 2)) + return newTrie }, success: true, }, @@ -1806,9 +1806,9 @@ func TestProposer_FilterAttestation(t *testing.T) { genesis := util.NewBeaconBlock() numValidators := uint64(64) - state, privKeys := util.DeterministicGenesisState(t, numValidators) - require.NoError(t, state.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:])) - assert.NoError(t, state.SetSlot(1)) + st, privKeys := util.DeterministicGenesisState(t, numValidators) + require.NoError(t, st.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:])) + assert.NoError(t, st.SetSlot(1)) genesisRoot, err := genesis.Block.HashTreeRoot() require.NoError(t, err) @@ -1857,12 +1857,12 @@ func TestProposer_FilterAttestation(t *testing.T) { }, AggregationBits: bitfield.Bitlist{0b00000110}, }) - committee, err := helpers.BeaconCommitteeFromState(context.Background(), state, atts[i].Data.Slot, atts[i].Data.CommitteeIndex) + committee, err := helpers.BeaconCommitteeFromState(context.Background(), st, atts[i].Data.Slot, atts[i].Data.CommitteeIndex) assert.NoError(t, err) attestingIndices, err := attestation.AttestingIndices(atts[i].AggregationBits, committee) require.NoError(t, err) assert.NoError(t, err) - domain, err := signing.Domain(state.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().ZeroHash[:]) + domain, err := signing.Domain(st.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().ZeroHash[:]) require.NoError(t, err) sigs := make([]bls.Signature, len(attestingIndices)) zeroSig := [96]byte{} @@ -1888,10 +1888,10 @@ func TestProposer_FilterAttestation(t *testing.T) { t.Run(tt.name, func(t *testing.T) { proposerServer := &Server{ AttPool: attestations.NewPool(), - HeadFetcher: &mock.ChainService{State: state, Root: genesisRoot[:]}, + HeadFetcher: &mock.ChainService{State: st, Root: genesisRoot[:]}, } atts := tt.inputAtts() - received, err := proposerServer.validateAndDeleteAttsInPool(context.Background(), state, atts) + received, err := proposerServer.validateAndDeleteAttsInPool(context.Background(), st, atts) if tt.wantedErr != "" { assert.ErrorContains(t, tt.wantedErr, err) assert.Equal(t, nil, received) @@ -2505,8 +2505,8 @@ func TestProposer_PrepareBeaconProposer(t *testing.T) { } func majorityVoteBoundaryTime(slot types.Slot) (uint64, uint64) { - slots := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().EpochsPerEth1VotingPeriod)) - slotStartTime := uint64(mockPOW.GenesisTime) + uint64((slot - (slot % (slots))).Mul(params.BeaconConfig().SecondsPerSlot)) + s := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().EpochsPerEth1VotingPeriod)) + slotStartTime := uint64(mockPOW.GenesisTime) + uint64((slot - (slot % (s))).Mul(params.BeaconConfig().SecondsPerSlot)) earliestValidTime := slotStartTime - 2*params.BeaconConfig().SecondsPerETH1Block*params.BeaconConfig().Eth1FollowDistance latestValidTime := slotStartTime - params.BeaconConfig().SecondsPerETH1Block*params.BeaconConfig().Eth1FollowDistance diff --git a/beacon-chain/rpc/prysm/v1alpha1/validator/server_test.go b/beacon-chain/rpc/prysm/v1alpha1/validator/server_test.go index 347e2c694f..d10fd7aff6 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/validator/server_test.go +++ b/beacon-chain/rpc/prysm/v1alpha1/validator/server_test.go @@ -140,7 +140,7 @@ func TestWaitForActivation_ValidatorOriginallyExists(t *testing.T) { root, err := depositTrie.HashTreeRoot() require.NoError(t, err) assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 10 /*blockNum*/, 0, root)) - trie, err := v1.InitializeFromProtoUnsafe(beaconState) + s, err := v1.InitializeFromProtoUnsafe(beaconState) require.NoError(t, err) vs := &Server{ Ctx: context.Background(), @@ -148,7 +148,7 @@ func TestWaitForActivation_ValidatorOriginallyExists(t *testing.T) { BlockFetcher: &mockPOW.POWChain{}, Eth1InfoFetcher: &mockPOW.POWChain{}, DepositFetcher: depositCache, - HeadFetcher: &mockChain.ChainService{State: trie, Root: genesisRoot[:]}, + HeadFetcher: &mockChain.ChainService{State: s, Root: genesisRoot[:]}, } req := ðpb.ValidatorActivationRequest{ PublicKeys: [][]byte{pubKey1, pubKey2}, @@ -219,12 +219,12 @@ func TestWaitForActivation_MultipleStatuses(t *testing.T) { block := util.NewBeaconBlock() genesisRoot, err := block.Block.HashTreeRoot() require.NoError(t, err, "Could not get signing root") - trie, err := v1.InitializeFromProtoUnsafe(beaconState) + s, err := v1.InitializeFromProtoUnsafe(beaconState) require.NoError(t, err) vs := &Server{ Ctx: context.Background(), ChainStartFetcher: &mockPOW.POWChain{}, - HeadFetcher: &mockChain.ChainService{State: trie, Root: genesisRoot[:]}, + HeadFetcher: &mockChain.ChainService{State: s, Root: genesisRoot[:]}, } req := ðpb.ValidatorActivationRequest{ PublicKeys: [][]byte{pubKey1, pubKey2, pubKey3}, diff --git a/beacon-chain/rpc/prysm/v1alpha1/validator/status.go b/beacon-chain/rpc/prysm/v1alpha1/validator/status.go index a289cef984..1ee46b3782 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/validator/status.go +++ b/beacon-chain/rpc/prysm/v1alpha1/validator/status.go @@ -334,9 +334,9 @@ func (vs *Server) validatorStatus( log.Warn("Not connected to ETH1. Cannot determine validator ETH1 deposit.") } else { // Check if there was a deposit deposit. - deposit, eth1BlockNumBigInt := vs.DepositFetcher.DepositByPubkey(ctx, pubKey) + d, eth1BlockNumBigInt := vs.DepositFetcher.DepositByPubkey(ctx, pubKey) if eth1BlockNumBigInt != nil { - resp.Status = depositStatus(deposit.Data.Amount) + resp.Status = depositStatus(d.Data.Amount) resp.Eth1DepositBlockNumber = eth1BlockNumBigInt.Uint64() } } diff --git a/beacon-chain/rpc/prysm/v1alpha1/validator/status_test.go b/beacon-chain/rpc/prysm/v1alpha1/validator/status_test.go index a2b46385cf..7dfd7cae8d 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/validator/status_test.go +++ b/beacon-chain/rpc/prysm/v1alpha1/validator/status_test.go @@ -180,10 +180,10 @@ func TestValidatorStatus_Pending(t *testing.T) { genesisRoot, err := block.Block.HashTreeRoot() require.NoError(t, err, "Could not get signing root") // Pending active because activation epoch is still defaulted at far future slot. - state, err := util.NewBeaconState() + st, err := util.NewBeaconState() require.NoError(t, err) - require.NoError(t, state.SetSlot(5000)) - err = state.SetValidators([]*ethpb.Validator{ + require.NoError(t, st.SetSlot(5000)) + err = st.SetValidators([]*ethpb.Validator{ { ActivationEpoch: params.BeaconConfig().FarFutureEpoch, ExitEpoch: params.BeaconConfig().FarFutureEpoch, @@ -223,7 +223,7 @@ func TestValidatorStatus_Pending(t *testing.T) { BlockFetcher: p, Eth1InfoFetcher: p, DepositFetcher: depositCache, - HeadFetcher: &mockChain.ChainService{State: state, Root: genesisRoot[:]}, + HeadFetcher: &mockChain.ChainService{State: st, Root: genesisRoot[:]}, } req := ðpb.ValidatorStatusRequest{ PublicKey: pubKey, @@ -266,7 +266,7 @@ func TestValidatorStatus_Active(t *testing.T) { genesisRoot, err := block.Block.HashTreeRoot() require.NoError(t, err, "Could not get signing root") - state := ðpb.BeaconState{ + st := ðpb.BeaconState{ GenesisTime: uint64(time.Unix(0, 0).Unix()), Slot: 10000, Validators: []*ethpb.Validator{{ @@ -275,7 +275,7 @@ func TestValidatorStatus_Active(t *testing.T) { WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch, PublicKey: pubKey}, }} - stateObj, err := v1.InitializeFromProtoUnsafe(state) + stateObj, err := v1.InitializeFromProtoUnsafe(st) require.NoError(t, err) timestamp := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix() @@ -320,7 +320,7 @@ func TestValidatorStatus_Exiting(t *testing.T) { genesisRoot, err := block.Block.HashTreeRoot() require.NoError(t, err, "Could not get signing root") - state := ðpb.BeaconState{ + st := ðpb.BeaconState{ Slot: slot, Validators: []*ethpb.Validator{{ PublicKey: pubKey, @@ -328,7 +328,7 @@ func TestValidatorStatus_Exiting(t *testing.T) { ExitEpoch: exitEpoch, WithdrawableEpoch: withdrawableEpoch}, }} - stateObj, err := v1.InitializeFromProtoUnsafe(state) + stateObj, err := v1.InitializeFromProtoUnsafe(st) require.NoError(t, err) depData := ðpb.Deposit_Data{ PublicKey: pubKey, @@ -380,14 +380,14 @@ func TestValidatorStatus_Slashing(t *testing.T) { genesisRoot, err := block.Block.HashTreeRoot() require.NoError(t, err, "Could not get signing root") - state := ðpb.BeaconState{ + st := ðpb.BeaconState{ Slot: slot, Validators: []*ethpb.Validator{{ Slashed: true, PublicKey: pubKey, WithdrawableEpoch: epoch + 1}, }} - stateObj, err := v1.InitializeFromProtoUnsafe(state) + stateObj, err := v1.InitializeFromProtoUnsafe(st) require.NoError(t, err) depData := ðpb.Deposit_Data{ PublicKey: pubKey, @@ -440,10 +440,10 @@ func TestValidatorStatus_Exited(t *testing.T) { require.NoError(t, err, "Could not get signing root") params.SetupTestConfigCleanup(t) params.OverrideBeaconConfig(params.MainnetConfig().Copy()) - state, err := util.NewBeaconState() + st, err := util.NewBeaconState() require.NoError(t, err) - require.NoError(t, state.SetSlot(slot)) - err = state.SetValidators([]*ethpb.Validator{{ + require.NoError(t, st.SetSlot(slot)) + err = st.SetValidators([]*ethpb.Validator{{ PublicKey: pubKey, WithdrawableEpoch: epoch + 1, WithdrawalCredentials: make([]byte, 32)}, @@ -477,7 +477,7 @@ func TestValidatorStatus_Exited(t *testing.T) { Eth1InfoFetcher: p, BlockFetcher: p, DepositFetcher: depositCache, - HeadFetcher: &mockChain.ChainService{State: state, Root: genesisRoot[:]}, + HeadFetcher: &mockChain.ChainService{State: st, Root: genesisRoot[:]}, } req := ðpb.ValidatorStatusRequest{ PublicKey: pubKey, @@ -677,10 +677,10 @@ func TestValidatorStatus_CorrectActivationQueue(t *testing.T) { WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch, }, } - state, err := util.NewBeaconState() + st, err := util.NewBeaconState() require.NoError(t, err) - require.NoError(t, state.SetValidators(validators)) - require.NoError(t, state.SetSlot(currentSlot)) + require.NoError(t, st.SetValidators(validators)) + require.NoError(t, st.SetSlot(currentSlot)) depositTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) require.NoError(t, err, "Could not setup deposit trie") @@ -714,7 +714,7 @@ func TestValidatorStatus_CorrectActivationQueue(t *testing.T) { BlockFetcher: p, Eth1InfoFetcher: p, DepositFetcher: depositCache, - HeadFetcher: &mockChain.ChainService{State: state, Root: genesisRoot[:]}, + HeadFetcher: &mockChain.ChainService{State: st, Root: genesisRoot[:]}, } req := ðpb.ValidatorStatusRequest{ PublicKey: pbKey, diff --git a/beacon-chain/rpc/service.go b/beacon-chain/rpc/service.go index d7bd2a6b1c..a228d96c81 100644 --- a/beacon-chain/rpc/service.go +++ b/beacon-chain/rpc/service.go @@ -11,8 +11,8 @@ import ( middleware "github.com/grpc-ecosystem/go-grpc-middleware" recovery "github.com/grpc-ecosystem/go-grpc-middleware/recovery" - grpc_opentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing" - grpc_prometheus "github.com/grpc-ecosystem/go-grpc-prometheus" + grpcopentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing" + grpcprometheus "github.com/grpc-ecosystem/go-grpc-prometheus" "github.com/prysmaticlabs/prysm/beacon-chain/blockchain" "github.com/prysmaticlabs/prysm/beacon-chain/cache" "github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache" @@ -140,16 +140,16 @@ func NewService(ctx context.Context, cfg *Config) *Service { recovery.StreamServerInterceptor( recovery.WithRecoveryHandlerContext(tracing.RecoveryHandlerFunc), ), - grpc_prometheus.StreamServerInterceptor, - grpc_opentracing.StreamServerInterceptor(), + grpcprometheus.StreamServerInterceptor, + grpcopentracing.StreamServerInterceptor(), s.validatorStreamConnectionInterceptor, )), grpc.UnaryInterceptor(middleware.ChainUnaryServer( recovery.UnaryServerInterceptor( recovery.WithRecoveryHandlerContext(tracing.RecoveryHandlerFunc), ), - grpc_prometheus.UnaryServerInterceptor, - grpc_opentracing.UnaryServerInterceptor(), + grpcprometheus.UnaryServerInterceptor, + grpcopentracing.UnaryServerInterceptor(), s.validatorUnaryConnectionInterceptor, )), grpc.MaxRecvMsgSize(s.cfg.MaxMsgSize), @@ -176,7 +176,7 @@ var _ stategen.CurrentSlotter = blockchain.ChainInfoFetcher(nil) // Start the gRPC server. func (s *Service) Start() { - grpc_prometheus.EnableHandlingTimeHistogram() + grpcprometheus.EnableHandlingTimeHistogram() var stateCache stategen.CachedGetter if s.cfg.StateGen != nil { diff --git a/beacon-chain/slasher/detect_attestations_test.go b/beacon-chain/slasher/detect_attestations_test.go index ba924d3f80..cbe29bd1e0 100644 --- a/beacon-chain/slasher/detect_attestations_test.go +++ b/beacon-chain/slasher/detect_attestations_test.go @@ -476,9 +476,9 @@ func Test_epochUpdateForValidators(t *testing.T) { func Test_applyAttestationForValidator_MinSpanChunk(t *testing.T) { ctx := context.Background() slasherDB := dbtest.SetupSlasherDB(t) - params := DefaultParams() + defaultParams := DefaultParams() srv := &Service{ - params: params, + params: defaultParams, serviceCfg: &ServiceConfig{ Database: slasherDB, StateNotifier: &mock.MockStateNotifier{}, @@ -486,7 +486,7 @@ func Test_applyAttestationForValidator_MinSpanChunk(t *testing.T) { latestEpochWrittenForValidator: map[types.ValidatorIndex]types.Epoch{}, } // We initialize an empty chunks slice. - chunk := EmptyMinSpanChunksSlice(params) + chunk := EmptyMinSpanChunksSlice(defaultParams) chunkIdx := uint64(0) currentEpoch := types.Epoch(3) validatorIdx := types.ValidatorIndex(0) @@ -537,9 +537,9 @@ func Test_applyAttestationForValidator_MinSpanChunk(t *testing.T) { func Test_applyAttestationForValidator_MaxSpanChunk(t *testing.T) { ctx := context.Background() slasherDB := dbtest.SetupSlasherDB(t) - params := DefaultParams() + defaultParams := DefaultParams() srv := &Service{ - params: params, + params: defaultParams, serviceCfg: &ServiceConfig{ Database: slasherDB, StateNotifier: &mock.MockStateNotifier{}, @@ -547,7 +547,7 @@ func Test_applyAttestationForValidator_MaxSpanChunk(t *testing.T) { latestEpochWrittenForValidator: map[types.ValidatorIndex]types.Epoch{}, } // We initialize an empty chunks slice. - chunk := EmptyMaxSpanChunksSlice(params) + chunk := EmptyMaxSpanChunksSlice(defaultParams) chunkIdx := uint64(0) currentEpoch := types.Epoch(3) validatorIdx := types.ValidatorIndex(0) @@ -687,7 +687,7 @@ func testLoadChunks(t *testing.T, kind slashertypes.ChunkKind) { ctx := context.Background() // Check if the chunk at chunk index already exists in-memory. - params := DefaultParams() + defaultParams := DefaultParams() s := &Service{ params: DefaultParams(), serviceCfg: &ServiceConfig{ @@ -699,9 +699,9 @@ func testLoadChunks(t *testing.T, kind slashertypes.ChunkKind) { // is initialized as an empty chunk. var emptyChunk Chunker if kind == slashertypes.MinSpan { - emptyChunk = EmptyMinSpanChunksSlice(params) + emptyChunk = EmptyMinSpanChunksSlice(defaultParams) } else { - emptyChunk = EmptyMaxSpanChunksSlice(params) + emptyChunk = EmptyMaxSpanChunksSlice(defaultParams) } chunkIdx := uint64(2) received, err := s.loadChunks(ctx, &chunkUpdateArgs{ @@ -717,15 +717,15 @@ func testLoadChunks(t *testing.T, kind slashertypes.ChunkKind) { // Save chunks to disk, then load them properly from disk. var existingChunk Chunker if kind == slashertypes.MinSpan { - existingChunk = EmptyMinSpanChunksSlice(params) + existingChunk = EmptyMinSpanChunksSlice(defaultParams) } else { - existingChunk = EmptyMaxSpanChunksSlice(params) + existingChunk = EmptyMaxSpanChunksSlice(defaultParams) } validatorIdx := types.ValidatorIndex(0) epochInChunk := types.Epoch(0) targetEpoch := types.Epoch(2) err = setChunkDataAtEpoch( - params, + defaultParams, existingChunk.Chunk(), validatorIdx, epochInChunk, diff --git a/beacon-chain/state/state-native/hasher_test.go b/beacon-chain/state/state-native/hasher_test.go index 6831dca8ca..2267b956c0 100644 --- a/beacon-chain/state/state-native/hasher_test.go +++ b/beacon-chain/state/state-native/hasher_test.go @@ -5,7 +5,7 @@ import ( "testing" "github.com/prysmaticlabs/go-bitfield" - state_native "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native" + statenative "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native" v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1" v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2" v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3" @@ -49,11 +49,11 @@ func TestComputeFieldRootsWithHasher_Phase0(t *testing.T) { require.Equal(t, true, ok) protoState, ok := v1State.InnerStateUnsafe().(*ethpb.BeaconState) require.Equal(t, true, ok) - initState, err := state_native.InitializeFromProtoPhase0(protoState) + initState, err := statenative.InitializeFromProtoPhase0(protoState) require.NoError(t, err) - s, ok := initState.(*state_native.BeaconState) + s, ok := initState.(*statenative.BeaconState) require.Equal(t, true, ok) - root, err := state_native.ComputeFieldRootsWithHasher(context.Background(), s) + root, err := statenative.ComputeFieldRootsWithHasher(context.Background(), s) require.NoError(t, err) expected := [][]byte{ {0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, @@ -115,12 +115,12 @@ func TestComputeFieldRootsWithHasher_Altair(t *testing.T) { require.Equal(t, true, ok) protoState, ok := v1State.InnerStateUnsafe().(*ethpb.BeaconStateAltair) require.Equal(t, true, ok) - initState, err := state_native.InitializeFromProtoAltair(protoState) + initState, err := statenative.InitializeFromProtoAltair(protoState) require.NoError(t, err) - s, ok := initState.(*state_native.BeaconState) + s, ok := initState.(*statenative.BeaconState) require.Equal(t, true, ok) - root, err := state_native.ComputeFieldRootsWithHasher(context.Background(), s) + root, err := statenative.ComputeFieldRootsWithHasher(context.Background(), s) require.NoError(t, err) expected := [][]byte{ {0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, @@ -186,12 +186,12 @@ func TestComputeFieldRootsWithHasher_Bellatrix(t *testing.T) { require.Equal(t, true, ok) protoState, ok := v1State.InnerStateUnsafe().(*ethpb.BeaconStateBellatrix) require.Equal(t, true, ok) - initState, err := state_native.InitializeFromProtoBellatrix(protoState) + initState, err := statenative.InitializeFromProtoBellatrix(protoState) require.NoError(t, err) - s, ok := initState.(*state_native.BeaconState) + s, ok := initState.(*statenative.BeaconState) require.Equal(t, true, ok) - root, err := state_native.ComputeFieldRootsWithHasher(context.Background(), s) + root, err := statenative.ComputeFieldRootsWithHasher(context.Background(), s) require.NoError(t, err) expected := [][]byte{ {0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, diff --git a/beacon-chain/state/state-native/readonly_validator_test.go b/beacon-chain/state/state-native/readonly_validator_test.go index cabae98cfc..3374d68b2a 100644 --- a/beacon-chain/state/state-native/readonly_validator_test.go +++ b/beacon-chain/state/state-native/readonly_validator_test.go @@ -67,8 +67,7 @@ func TestReadOnlyValidator_WithdrawalCredentials(t *testing.T) { } func TestReadOnlyValidator_Slashed(t *testing.T) { - slashed := true - v, err := statenative.NewValidator(ðpb.Validator{Slashed: slashed}) + v, err := statenative.NewValidator(ðpb.Validator{Slashed: true}) require.NoError(t, err) - assert.Equal(t, slashed, v.Slashed()) + assert.Equal(t, true, v.Slashed()) } diff --git a/beacon-chain/state/stategen/replay.go b/beacon-chain/state/stategen/replay.go index d12cedcc4e..6c2e46f482 100644 --- a/beacon-chain/state/stategen/replay.go +++ b/beacon-chain/state/stategen/replay.go @@ -228,7 +228,7 @@ func ReplayProcessSlots(ctx context.Context, state state.BeaconState, slot types } if prysmtime.CanUpgradeToBellatrix(state.Slot()) { - state, err = execution.UpgradeToBellatrix(ctx, state) + state, err = execution.UpgradeToBellatrix(state) if err != nil { tracing.AnnotateError(span, err) return nil, err diff --git a/beacon-chain/state/testing/getters.go b/beacon-chain/state/testing/getters.go index 7493b0420a..252dfce799 100644 --- a/beacon-chain/state/testing/getters.go +++ b/beacon-chain/state/testing/getters.go @@ -89,13 +89,6 @@ func VerifyBeaconStateMarshalSSZNilState(t *testing.T, factory getState, clear c require.ErrorContains(t, "nil beacon state", err) } -func VerifyBeaconStateMarshalSSZNilStateNative(t *testing.T, factory getState) { - s, err := factory() - require.NoError(t, err) - _, err = s.MarshalSSZ() - require.ErrorContains(t, "nil beacon state", err) -} - func VerifyBeaconStateValidatorByPubkey(t *testing.T, factory getState) { keyCreator := func(input []byte) [fieldparams.BLSPubkeyLength]byte { nKey := [fieldparams.BLSPubkeyLength]byte{} diff --git a/beacon-chain/state/v1/readonly_validator_test.go b/beacon-chain/state/v1/readonly_validator_test.go index 18b4fcd9dd..c94e4e808b 100644 --- a/beacon-chain/state/v1/readonly_validator_test.go +++ b/beacon-chain/state/v1/readonly_validator_test.go @@ -67,8 +67,7 @@ func TestReadOnlyValidator_WithdrawalCredentials(t *testing.T) { } func TestReadOnlyValidator_Slashed(t *testing.T) { - slashed := true - v, err := v1.NewValidator(ðpb.Validator{Slashed: slashed}) + v, err := v1.NewValidator(ðpb.Validator{Slashed: true}) require.NoError(t, err) - assert.Equal(t, slashed, v.Slashed()) + assert.Equal(t, true, v.Slashed()) } diff --git a/beacon-chain/state/v1/unsupported_setters.go b/beacon-chain/state/v1/unsupported_setters.go index 8a0c6734fc..f57115e946 100644 --- a/beacon-chain/state/v1/unsupported_setters.go +++ b/beacon-chain/state/v1/unsupported_setters.go @@ -42,12 +42,12 @@ func (*BeaconState) SetCurrentParticipationBits(_ []byte) error { } // ModifyPreviousParticipationBits is not supported for phase 0 beacon state. -func (b *BeaconState) ModifyPreviousParticipationBits(mutator func(val []byte) ([]byte, error)) error { +func (b *BeaconState) ModifyPreviousParticipationBits(_ func(val []byte) ([]byte, error)) error { return errors.New("ModifyPreviousParticipationBits is not supported for phase 0 beacon state") } // ModifyCurrentParticipationBits is not supported for phase 0 beacon state. -func (b *BeaconState) ModifyCurrentParticipationBits(mutator func(val []byte) ([]byte, error)) error { +func (b *BeaconState) ModifyCurrentParticipationBits(_ func(val []byte) ([]byte, error)) error { return errors.New("ModifyCurrentParticipationBits is not supported for phase 0 beacon state") } @@ -57,6 +57,6 @@ func (*BeaconState) SetInactivityScores(_ []uint64) error { } // SetLatestExecutionPayloadHeader is not supported for phase 0 beacon state. -func (*BeaconState) SetLatestExecutionPayloadHeader(val *enginev1.ExecutionPayloadHeader) error { +func (*BeaconState) SetLatestExecutionPayloadHeader(_ *enginev1.ExecutionPayloadHeader) error { return errors.New("SetLatestExecutionPayloadHeader is not supported for phase 0 beacon state") } diff --git a/beacon-chain/sync/fork_watcher_test.go b/beacon-chain/sync/fork_watcher_test.go index 57a4b3ca80..f162e3c595 100644 --- a/beacon-chain/sync/fork_watcher_test.go +++ b/beacon-chain/sync/fork_watcher_test.go @@ -28,7 +28,7 @@ func TestService_CheckForNextEpochFork(t *testing.T) { { name: "no fork in the next epoch", svcCreator: func(t *testing.T) *Service { - p2p := p2ptest.NewTestP2P(t) + peer2peer := p2ptest.NewTestP2P(t) chainService := &mockChain.ChainService{ Genesis: time.Now().Add(time.Duration(-params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().SlotsPerEpoch))) * time.Second), ValidatorsRoot: [32]byte{'A'}, @@ -38,7 +38,7 @@ func TestService_CheckForNextEpochFork(t *testing.T) { ctx: ctx, cancel: cancel, cfg: &config{ - p2p: p2p, + p2p: peer2peer, chain: chainService, stateNotifier: chainService.StateNotifier(), initialSync: &mockSync.Sync{IsSyncing: false}, @@ -57,7 +57,7 @@ func TestService_CheckForNextEpochFork(t *testing.T) { { name: "altair fork in the next epoch", svcCreator: func(t *testing.T) *Service { - p2p := p2ptest.NewTestP2P(t) + peer2peer := p2ptest.NewTestP2P(t) chainService := &mockChain.ChainService{ Genesis: time.Now().Add(-4 * oneEpoch()), ValidatorsRoot: [32]byte{'A'}, @@ -71,7 +71,7 @@ func TestService_CheckForNextEpochFork(t *testing.T) { ctx: ctx, cancel: cancel, cfg: &config{ - p2p: p2p, + p2p: peer2peer, chain: chainService, stateNotifier: chainService.StateNotifier(), initialSync: &mockSync.Sync{IsSyncing: false}, @@ -100,7 +100,7 @@ func TestService_CheckForNextEpochFork(t *testing.T) { { name: "bellatrix fork in the next epoch", svcCreator: func(t *testing.T) *Service { - p2p := p2ptest.NewTestP2P(t) + peer2peer := p2ptest.NewTestP2P(t) chainService := &mockChain.ChainService{ Genesis: time.Now().Add(-4 * oneEpoch()), ValidatorsRoot: [32]byte{'A'}, @@ -115,7 +115,7 @@ func TestService_CheckForNextEpochFork(t *testing.T) { ctx: ctx, cancel: cancel, cfg: &config{ - p2p: p2p, + p2p: peer2peer, chain: chainService, stateNotifier: chainService.StateNotifier(), initialSync: &mockSync.Sync{IsSyncing: false}, @@ -162,7 +162,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) { { name: "no fork in the previous epoch", svcCreator: func(t *testing.T) *Service { - p2p := p2ptest.NewTestP2P(t) + peer2peer := p2ptest.NewTestP2P(t) chainService := &mockChain.ChainService{ Genesis: time.Now().Add(-oneEpoch()), ValidatorsRoot: [32]byte{'A'}, @@ -172,7 +172,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) { ctx: ctx, cancel: cancel, cfg: &config{ - p2p: p2p, + p2p: peer2peer, chain: chainService, stateNotifier: chainService.StateNotifier(), initialSync: &mockSync.Sync{IsSyncing: false}, @@ -202,7 +202,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) { { name: "altair fork in the previous epoch", svcCreator: func(t *testing.T) *Service { - p2p := p2ptest.NewTestP2P(t) + peer2peer := p2ptest.NewTestP2P(t) chainService := &mockChain.ChainService{ Genesis: time.Now().Add(-4 * oneEpoch()), ValidatorsRoot: [32]byte{'A'}, @@ -216,7 +216,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) { ctx: ctx, cancel: cancel, cfg: &config{ - p2p: p2p, + p2p: peer2peer, chain: chainService, stateNotifier: chainService.StateNotifier(), initialSync: &mockSync.Sync{IsSyncing: false}, @@ -276,7 +276,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) { { name: "bellatrix fork in the previous epoch", svcCreator: func(t *testing.T) *Service { - p2p := p2ptest.NewTestP2P(t) + peer2peer := p2ptest.NewTestP2P(t) chainService := &mockChain.ChainService{ Genesis: time.Now().Add(-4 * oneEpoch()), ValidatorsRoot: [32]byte{'A'}, @@ -291,7 +291,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) { ctx: ctx, cancel: cancel, cfg: &config{ - p2p: p2p, + p2p: peer2peer, chain: chainService, stateNotifier: chainService.StateNotifier(), initialSync: &mockSync.Sync{IsSyncing: false}, diff --git a/beacon-chain/sync/initial-sync/blocks_fetcher_test.go b/beacon-chain/sync/initial-sync/blocks_fetcher_test.go index 01fa3ef869..3dbb7e0243 100644 --- a/beacon-chain/sync/initial-sync/blocks_fetcher_test.go +++ b/beacon-chain/sync/initial-sync/blocks_fetcher_test.go @@ -343,14 +343,14 @@ func TestBlocksFetcher_RoundRobin(t *testing.T) { return blocks[i].Block().Slot() < blocks[j].Block().Slot() }) - slots := make([]types.Slot, len(blocks)) + ss := make([]types.Slot, len(blocks)) for i, block := range blocks { - slots[i] = block.Block().Slot() + ss[i] = block.Block().Slot() } log.WithFields(logrus.Fields{ "blocksLen": len(blocks), - "slots": slots, + "slots": ss, }).Debug("Finished block fetching") if len(blocks) > int(maxExpectedBlocks) { diff --git a/beacon-chain/sync/initial-sync/blocks_queue.go b/beacon-chain/sync/initial-sync/blocks_queue.go index 99ad23342b..df8a3c00c6 100644 --- a/beacon-chain/sync/initial-sync/blocks_queue.go +++ b/beacon-chain/sync/initial-sync/blocks_queue.go @@ -432,7 +432,7 @@ func (q *blocksQueue) onProcessSkippedEvent(ctx context.Context) eventHandlerFn delete(q.staleEpochs, slots.ToEpoch(startSlot)) fork, err := q.blocksFetcher.findFork(ctx, startSlot) if err == nil { - return stateSkipped, q.resetFromFork(ctx, fork) + return stateSkipped, q.resetFromFork(fork) } log.WithFields(logrus.Fields{ "epoch": slots.ToEpoch(startSlot), diff --git a/beacon-chain/sync/initial-sync/blocks_queue_utils.go b/beacon-chain/sync/initial-sync/blocks_queue_utils.go index f5af53ce7e..0231f02c8e 100644 --- a/beacon-chain/sync/initial-sync/blocks_queue_utils.go +++ b/beacon-chain/sync/initial-sync/blocks_queue_utils.go @@ -10,7 +10,7 @@ import ( // resetWithBlocks removes all state machines, then re-adds enough machines to contain all provided // blocks (machines are set into stateDataParsed state, so that their content is immediately // consumable). It is assumed that blocks come in an ascending order. -func (q *blocksQueue) resetFromFork(ctx context.Context, fork *forkData) error { +func (q *blocksQueue) resetFromFork(fork *forkData) error { if fork == nil { return errors.New("nil fork data") } diff --git a/beacon-chain/sync/initial-sync/initial_sync_test.go b/beacon-chain/sync/initial-sync/initial_sync_test.go index 8847b110fb..9f7b453e41 100644 --- a/beacon-chain/sync/initial-sync/initial_sync_test.go +++ b/beacon-chain/sync/initial-sync/initial_sync_test.go @@ -188,10 +188,10 @@ func connectPeer(t *testing.T, host *p2pt.TestP2P, datum *peerData, peerStatus * } // Determine the correct subset of blocks to return as dictated by the test scenario. - slots := slice.IntersectionSlot(datum.blocks, requestedBlocks) + ss := slice.IntersectionSlot(datum.blocks, requestedBlocks) ret := make([]*ethpb.SignedBeaconBlock, 0) - for _, slot := range slots { + for _, slot := range ss { if (slot - req.StartSlot).Mod(req.Step) != 0 { continue } diff --git a/beacon-chain/sync/pending_blocks_queue.go b/beacon-chain/sync/pending_blocks_queue.go index 0cfc034e78..8d532a3159 100644 --- a/beacon-chain/sync/pending_blocks_queue.go +++ b/beacon-chain/sync/pending_blocks_queue.go @@ -57,16 +57,16 @@ func (s *Service) processPendingBlocks(ctx context.Context) error { if err := s.validatePendingSlots(); err != nil { return errors.Wrap(err, "could not validate pending slots") } - slots := s.sortedPendingSlots() + ss := s.sortedPendingSlots() var parentRoots [][32]byte span.AddAttributes( - trace.Int64Attribute("numSlots", int64(len(slots))), + trace.Int64Attribute("numSlots", int64(len(ss))), trace.Int64Attribute("numPeers", int64(len(pids))), ) randGen := rand.NewGenerator() - for _, slot := range slots { + for _, slot := range ss { // process the blocks during their respective slot. // otherwise wait for the right slot to process the block. if slot > s.cfg.chain.CurrentSlot() { @@ -257,15 +257,15 @@ func (s *Service) sortedPendingSlots() []types.Slot { items := s.slotToPendingBlocks.Items() - slots := make([]types.Slot, 0, len(items)) + ss := make([]types.Slot, 0, len(items)) for k := range items { slot := cacheKeyToSlot(k) - slots = append(slots, slot) + ss = append(ss, slot) } - sort.Slice(slots, func(i, j int) bool { - return slots[i] < slots[j] + sort.Slice(ss, func(i, j int) bool { + return ss[i] < ss[j] }) - return slots + return ss } // validatePendingSlots validates the pending blocks diff --git a/beacon-chain/sync/rpc_metadata_test.go b/beacon-chain/sync/rpc_metadata_test.go index 938ea90970..eabd694d08 100644 --- a/beacon-chain/sync/rpc_metadata_test.go +++ b/beacon-chain/sync/rpc_metadata_test.go @@ -122,11 +122,11 @@ func TestMetadataRPCHandler_SendsMetadata(t *testing.T) { assert.NoError(t, r2.metaDataHandler(context.Background(), new(interface{}), stream)) }) - metadata, err := r.sendMetaDataRequest(context.Background(), p2.BHost.ID()) + md, err := r.sendMetaDataRequest(context.Background(), p2.BHost.ID()) assert.NoError(t, err) - if !equality.DeepEqual(metadata.InnerObject(), p2.LocalMetadata.InnerObject()) { - t.Fatalf("MetadataV0 unequal, received %v but wanted %v", metadata, p2.LocalMetadata) + if !equality.DeepEqual(md.InnerObject(), p2.LocalMetadata.InnerObject()) { + t.Fatalf("MetadataV0 unequal, received %v but wanted %v", md, p2.LocalMetadata) } if util.WaitTimeout(&wg, 1*time.Second) { @@ -210,11 +210,11 @@ func TestMetadataRPCHandler_SendsMetadataAltair(t *testing.T) { assert.NoError(t, r2.metaDataHandler(context.Background(), new(interface{}), stream)) }) - metadata, err := r.sendMetaDataRequest(context.Background(), p2.BHost.ID()) + md, err := r.sendMetaDataRequest(context.Background(), p2.BHost.ID()) assert.NoError(t, err) - if !equality.DeepEqual(metadata.InnerObject(), p2.LocalMetadata.InnerObject()) { - t.Fatalf("MetadataV1 unequal, received %v but wanted %v", metadata, p2.LocalMetadata) + if !equality.DeepEqual(md.InnerObject(), p2.LocalMetadata.InnerObject()) { + t.Fatalf("MetadataV1 unequal, received %v but wanted %v", md, p2.LocalMetadata) } if util.WaitTimeout(&wg, 1*time.Second) { diff --git a/beacon-chain/sync/service.go b/beacon-chain/sync/service.go index c085d86704..4e04acbf50 100644 --- a/beacon-chain/sync/service.go +++ b/beacon-chain/sync/service.go @@ -237,10 +237,10 @@ func (s *Service) registerHandlers() { defer stateSub.Unsubscribe() for { select { - case event := <-stateChannel: - switch event.Type { + case e := <-stateChannel: + switch e.Type { case statefeed.Initialized: - data, ok := event.Data.(*statefeed.InitializedData) + data, ok := e.Data.(*statefeed.InitializedData) if !ok { log.Error("Event feed data is not type *statefeed.InitializedData") return @@ -259,7 +259,7 @@ func (s *Service) registerHandlers() { s.markForChainStart() }() case statefeed.Synced: - _, ok := event.Data.(*statefeed.SyncedData) + _, ok := e.Data.(*statefeed.SyncedData) if !ok { log.Error("Event feed data is not type *statefeed.SyncedData") return diff --git a/beacon-chain/sync/subscriber.go b/beacon-chain/sync/subscriber.go index bc5de96a7d..9785d24f58 100644 --- a/beacon-chain/sync/subscriber.go +++ b/beacon-chain/sync/subscriber.go @@ -680,14 +680,14 @@ func (s *Service) filterNeededPeers(pids []peer.ID) []peer.ID { for _, sub := range wantedSubs { subnetTopic := fmt.Sprintf(topic, digest, sub) + s.cfg.p2p.Encoding().ProtocolSuffix() - peers := s.cfg.p2p.PubSub().ListPeers(subnetTopic) - if len(peers) > flags.Get().MinimumPeersPerSubnet { + ps := s.cfg.p2p.PubSub().ListPeers(subnetTopic) + if len(ps) > flags.Get().MinimumPeersPerSubnet { // In the event we have more than the minimum, we can // mark the remaining as viable for pruning. - peers = peers[:flags.Get().MinimumPeersPerSubnet] + ps = ps[:flags.Get().MinimumPeersPerSubnet] } // Add peer to peer map. - for _, p := range peers { + for _, p := range ps { // Even if the peer id has // already been seen we still set // it, as the outcome is the same. diff --git a/beacon-chain/sync/validate_attester_slashing_test.go b/beacon-chain/sync/validate_attester_slashing_test.go index 2dfa63e0aa..bf870c1969 100644 --- a/beacon-chain/sync/validate_attester_slashing_test.go +++ b/beacon-chain/sync/validate_attester_slashing_test.go @@ -26,12 +26,12 @@ import ( ) func setupValidAttesterSlashing(t *testing.T) (*ethpb.AttesterSlashing, state.BeaconState) { - state, privKeys := util.DeterministicGenesisState(t, 5) - vals := state.Validators() + s, privKeys := util.DeterministicGenesisState(t, 5) + vals := s.Validators() for _, vv := range vals { vv.WithdrawableEpoch = types.Epoch(1 * params.BeaconConfig().SlotsPerEpoch) } - require.NoError(t, state.SetValidators(vals)) + require.NoError(t, s.SetValidators(vals)) att1 := util.HydrateIndexedAttestation(ðpb.IndexedAttestation{ Data: ðpb.AttestationData{ @@ -39,7 +39,7 @@ func setupValidAttesterSlashing(t *testing.T) (*ethpb.AttesterSlashing, state.Be }, AttestingIndices: []uint64{0, 1}, }) - domain, err := signing.Domain(state.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, state.GenesisValidatorsRoot()) + domain, err := signing.Domain(s.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, s.GenesisValidatorsRoot()) require.NoError(t, err) hashTreeRoot, err := signing.ComputeSigningRoot(att1.Data, domain) assert.NoError(t, err) @@ -64,13 +64,13 @@ func setupValidAttesterSlashing(t *testing.T) (*ethpb.AttesterSlashing, state.Be } currentSlot := 2 * params.BeaconConfig().SlotsPerEpoch - require.NoError(t, state.SetSlot(currentSlot)) + require.NoError(t, s.SetSlot(currentSlot)) b := make([]byte, 32) _, err = rand.Read(b) require.NoError(t, err) - return slashing, state + return slashing, s } func TestValidateAttesterSlashing_ValidSlashing(t *testing.T) { @@ -178,7 +178,7 @@ func TestValidateAttesterSlashing_CanFilter(t *testing.T) { func TestValidateAttesterSlashing_ContextTimeout(t *testing.T) { p := p2ptest.NewTestP2P(t) - slashing, state := setupValidAttesterSlashing(t) + slashing, s := setupValidAttesterSlashing(t) slashing.Attestation_1.Data.Target.Epoch = 100000000 ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) @@ -187,7 +187,7 @@ func TestValidateAttesterSlashing_ContextTimeout(t *testing.T) { r := &Service{ cfg: &config{ p2p: p, - chain: &mock.ChainService{State: state}, + chain: &mock.ChainService{State: s}, initialSync: &mockSync.Sync{IsSyncing: false}, }, seenAttesterSlashingCache: make(map[uint64]bool), diff --git a/beacon-chain/sync/validate_proposer_slashing_test.go b/beacon-chain/sync/validate_proposer_slashing_test.go index 50cb54a415..0ceb1cf72e 100644 --- a/beacon-chain/sync/validate_proposer_slashing_test.go +++ b/beacon-chain/sync/validate_proposer_slashing_test.go @@ -45,7 +45,7 @@ func setupValidProposerSlashing(t *testing.T) (*ethpb.ProposerSlashing, state.Be } currentSlot := types.Slot(0) - state, err := v1.InitializeFromProto(ðpb.BeaconState{ + st, err := v1.InitializeFromProto(ðpb.BeaconState{ Validators: validators, Slot: currentSlot, Balances: validatorBalances, @@ -76,7 +76,7 @@ func setupValidProposerSlashing(t *testing.T) (*ethpb.ProposerSlashing, state.Be BodyRoot: someRoot[:], }, } - header1.Signature, err = signing.ComputeDomainAndSign(state, coreTime.CurrentEpoch(state), header1.Header, params.BeaconConfig().DomainBeaconProposer, privKey) + header1.Signature, err = signing.ComputeDomainAndSign(st, coreTime.CurrentEpoch(st), header1.Header, params.BeaconConfig().DomainBeaconProposer, privKey) require.NoError(t, err) header2 := ðpb.SignedBeaconBlockHeader{ @@ -88,23 +88,23 @@ func setupValidProposerSlashing(t *testing.T) (*ethpb.ProposerSlashing, state.Be BodyRoot: someRoot2[:], }, } - header2.Signature, err = signing.ComputeDomainAndSign(state, coreTime.CurrentEpoch(state), header2.Header, params.BeaconConfig().DomainBeaconProposer, privKey) + header2.Signature, err = signing.ComputeDomainAndSign(st, coreTime.CurrentEpoch(st), header2.Header, params.BeaconConfig().DomainBeaconProposer, privKey) require.NoError(t, err) slashing := ðpb.ProposerSlashing{ Header_1: header1, Header_2: header2, } - val, err := state.ValidatorAtIndex(1) + val, err := st.ValidatorAtIndex(1) require.NoError(t, err) val.PublicKey = privKey.PublicKey().Marshal() - require.NoError(t, state.UpdateValidatorAtIndex(1, val)) + require.NoError(t, st.UpdateValidatorAtIndex(1, val)) b := make([]byte, 32) _, err = rand.Read(b) require.NoError(t, err) - return slashing, state + return slashing, st } func TestValidateProposerSlashing_ValidSlashing(t *testing.T) { @@ -146,11 +146,11 @@ func TestValidateProposerSlashing_ValidSlashing(t *testing.T) { func TestValidateProposerSlashing_ContextTimeout(t *testing.T) { p := p2ptest.NewTestP2P(t) - slashing, state := setupValidProposerSlashing(t) + slashing, st := setupValidProposerSlashing(t) slashing.Header_1.Header.Slot = 100000000 - err := state.SetJustificationBits(bitfield.Bitvector4{0x0F}) // 0b1111 + err := st.SetJustificationBits(bitfield.Bitvector4{0x0F}) // 0b1111 require.NoError(t, err) - err = state.SetPreviousJustifiedCheckpoint(ðpb.Checkpoint{Epoch: 0, Root: []byte{}}) + err = st.SetPreviousJustifiedCheckpoint(ðpb.Checkpoint{Epoch: 0, Root: []byte{}}) require.NoError(t, err) ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) defer cancel() @@ -158,7 +158,7 @@ func TestValidateProposerSlashing_ContextTimeout(t *testing.T) { r := &Service{ cfg: &config{ p2p: p, - chain: &mock.ChainService{State: state}, + chain: &mock.ChainService{State: st}, initialSync: &mockSync.Sync{IsSyncing: false}, }, seenProposerSlashingCache: lruwrpr.New(10), diff --git a/beacon-chain/sync/validate_sync_committee_message_test.go b/beacon-chain/sync/validate_sync_committee_message_test.go index 4407d200e0..4668dfcaa3 100644 --- a/beacon-chain/sync/validate_sync_committee_message_test.go +++ b/beacon-chain/sync/validate_sync_committee_message_test.go @@ -11,10 +11,10 @@ import ( "github.com/golang/snappy" "github.com/libp2p/go-libp2p-core/peer" pubsub "github.com/libp2p/go-libp2p-pubsub" - pubsub_pb "github.com/libp2p/go-libp2p-pubsub/pb" + pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb" mockChain "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing" "github.com/prysmaticlabs/prysm/beacon-chain/core/signing" - testingDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing" + testingdb "github.com/prysmaticlabs/prysm/beacon-chain/db/testing" "github.com/prysmaticlabs/prysm/beacon-chain/p2p" "github.com/prysmaticlabs/prysm/beacon-chain/p2p/encoder" mockp2p "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing" @@ -31,7 +31,7 @@ import ( ) func TestService_ValidateSyncCommitteeMessage(t *testing.T) { - beaconDB := testingDB.SetupDB(t) + beaconDB := testingdb.SetupDB(t) headRoot, keys := fillUpBlocksAndState(context.Background(), t, beaconDB) defaultTopic := p2p.SyncCommitteeSubnetTopicFormat fakeDigest := []byte{0xAB, 0x00, 0xCC, 0x9E} @@ -417,7 +417,7 @@ func TestService_ValidateSyncCommitteeMessage(t *testing.T) { assert.NoError(t, err) marshalledObj = snappy.Encode(nil, marshalledObj) msg := &pubsub.Message{ - Message: &pubsub_pb.Message{ + Message: &pubsubpb.Message{ Data: marshalledObj, Topic: &tt.args.topic, }, @@ -583,7 +583,7 @@ func TestValidateSyncCommitteeMessage_Optimistic(t *testing.T) { topic := p2p.GossipTypeMapping[reflect.TypeOf(slashing)] msg := &pubsub.Message{ - Message: &pubsub_pb.Message{ + Message: &pubsubpb.Message{ Data: buf.Bytes(), Topic: &topic, }, diff --git a/beacon-chain/sync/validate_sync_contribution_proof_test.go b/beacon-chain/sync/validate_sync_contribution_proof_test.go index 25e3b26eb6..ba3f74ff77 100644 --- a/beacon-chain/sync/validate_sync_contribution_proof_test.go +++ b/beacon-chain/sync/validate_sync_contribution_proof_test.go @@ -11,7 +11,7 @@ import ( "github.com/golang/snappy" "github.com/libp2p/go-libp2p-core/peer" pubsub "github.com/libp2p/go-libp2p-pubsub" - pubsub_pb "github.com/libp2p/go-libp2p-pubsub/pb" + pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb" "github.com/prysmaticlabs/go-bitfield" mockChain "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing" "github.com/prysmaticlabs/prysm/beacon-chain/core/altair" @@ -20,7 +20,7 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/core/signing" "github.com/prysmaticlabs/prysm/beacon-chain/core/transition" "github.com/prysmaticlabs/prysm/beacon-chain/db" - testingDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing" + testingdb "github.com/prysmaticlabs/prysm/beacon-chain/db/testing" "github.com/prysmaticlabs/prysm/beacon-chain/p2p" "github.com/prysmaticlabs/prysm/beacon-chain/p2p/encoder" mockp2p "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing" @@ -41,8 +41,8 @@ import ( ) func TestService_ValidateSyncContributionAndProof(t *testing.T) { - db := testingDB.SetupDB(t) - headRoot, keys := fillUpBlocksAndState(context.Background(), t, db) + database := testingdb.SetupDB(t) + headRoot, keys := fillUpBlocksAndState(context.Background(), t, database) defaultTopic := p2p.SyncContributionAndProofSubnetTopicFormat defaultTopic = fmt.Sprintf(defaultTopic, []byte{0xAB, 0x00, 0xCC, 0x9E}) defaultTopic = defaultTopic + "/" + encoder.ProtocolSuffixSSZSnappy @@ -74,9 +74,9 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) + s.cfg.stateGen = stategen.New(database) msg.Message.Contribution.BlockRoot = headRoot[:] - s.cfg.beaconDB = db + s.cfg.beaconDB = database s.initCaches() return s }, @@ -110,9 +110,9 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) + s.cfg.stateGen = stategen.New(database) msg.Message.Contribution.BlockRoot = headRoot[:] - s.cfg.beaconDB = db + s.cfg.beaconDB = database s.initCaches() return s }, @@ -146,8 +146,8 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) - s.cfg.beaconDB = db + s.cfg.stateGen = stategen.New(database) + s.cfg.beaconDB = database s.initCaches() return s }, @@ -181,8 +181,8 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) - s.cfg.beaconDB = db + s.cfg.stateGen = stategen.New(database) + s.cfg.beaconDB = database s.initCaches() s.cfg.chain = &mockChain.ChainService{ ValidatorsRoot: [32]byte{'A'}, @@ -224,8 +224,8 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) - s.cfg.beaconDB = db + s.cfg.stateGen = stategen.New(database) + s.cfg.beaconDB = database s.initCaches() s.cfg.chain = &mockChain.ChainService{ ValidatorsRoot: [32]byte{'A'}, @@ -267,8 +267,8 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) - s.cfg.beaconDB = db + s.cfg.stateGen = stategen.New(database) + s.cfg.beaconDB = database s.initCaches() s.cfg.chain = &mockChain.ChainService{ ValidatorsRoot: [32]byte{'A'}, @@ -311,15 +311,15 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) - s.cfg.beaconDB = db + s.cfg.stateGen = stategen.New(database) + s.cfg.beaconDB = database s.initCaches() s.cfg.chain = &mockChain.ChainService{ ValidatorsRoot: [32]byte{'A'}, Genesis: time.Now().Add(-time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Duration(msg.Message.Contribution.Slot)), } msg.Message.Contribution.BlockRoot = headRoot[:] - hState, err := db.State(context.Background(), headRoot) + hState, err := database.State(context.Background(), headRoot) assert.NoError(t, err) sc, err := hState.CurrentSyncCommittee() assert.NoError(t, err) @@ -373,10 +373,10 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) - s.cfg.beaconDB = db + s.cfg.stateGen = stategen.New(database) + s.cfg.beaconDB = database msg.Message.Contribution.BlockRoot = headRoot[:] - hState, err := db.State(context.Background(), headRoot) + hState, err := database.State(context.Background(), headRoot) assert.NoError(t, err) sc, err := hState.CurrentSyncCommittee() assert.NoError(t, err) @@ -438,11 +438,11 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) - s.cfg.beaconDB = db + s.cfg.stateGen = stategen.New(database) + s.cfg.beaconDB = database s.cfg.chain = chainService msg.Message.Contribution.BlockRoot = headRoot[:] - hState, err := db.State(context.Background(), headRoot) + hState, err := database.State(context.Background(), headRoot) assert.NoError(t, err) sc, err := hState.CurrentSyncCommittee() assert.NoError(t, err) @@ -518,10 +518,10 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) - s.cfg.beaconDB = db + s.cfg.stateGen = stategen.New(database) + s.cfg.beaconDB = database msg.Message.Contribution.BlockRoot = headRoot[:] - hState, err := db.State(context.Background(), headRoot) + hState, err := database.State(context.Background(), headRoot) assert.NoError(t, err) sc, err := hState.CurrentSyncCommittee() assert.NoError(t, err) @@ -600,10 +600,10 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) + s.cfg.stateGen = stategen.New(database) msg.Message.Contribution.BlockRoot = headRoot[:] - s.cfg.beaconDB = db - hState, err := db.State(context.Background(), headRoot) + s.cfg.beaconDB = database + hState, err := database.State(context.Background(), headRoot) assert.NoError(t, err) sc, err := hState.CurrentSyncCommittee() assert.NoError(t, err) @@ -684,10 +684,10 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) + s.cfg.stateGen = stategen.New(database) msg.Message.Contribution.BlockRoot = headRoot[:] - s.cfg.beaconDB = db - hState, err := db.State(context.Background(), headRoot) + s.cfg.beaconDB = database + hState, err := database.State(context.Background(), headRoot) assert.NoError(t, err) sc, err := hState.CurrentSyncCommittee() assert.NoError(t, err) @@ -780,10 +780,10 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ), setupSvc: func(s *Service, msg *ethpb.SignedContributionAndProof) *Service { - s.cfg.stateGen = stategen.New(db) + s.cfg.stateGen = stategen.New(database) msg.Message.Contribution.BlockRoot = headRoot[:] - s.cfg.beaconDB = db - hState, err := db.State(context.Background(), headRoot) + s.cfg.beaconDB = database + hState, err := database.State(context.Background(), headRoot) assert.NoError(t, err) sc, err := hState.CurrentSyncCommittee() assert.NoError(t, err) @@ -877,7 +877,7 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { assert.NoError(t, err) marshalledObj = snappy.Encode(nil, marshalledObj) msg := &pubsub.Message{ - Message: &pubsub_pb.Message{ + Message: &pubsubpb.Message{ Data: marshalledObj, Topic: &tt.args.topic, }, @@ -894,8 +894,8 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) { func TestValidateSyncContributionAndProof(t *testing.T) { ctx := context.Background() - db := testingDB.SetupDB(t) - headRoot, keys := fillUpBlocksAndState(ctx, t, db) + database := testingdb.SetupDB(t) + headRoot, keys := fillUpBlocksAndState(ctx, t, database) defaultTopic := p2p.SyncContributionAndProofSubnetTopicFormat defaultTopic = fmt.Sprintf(defaultTopic, []byte{0xAB, 0x00, 0xCC, 0x9E}) defaultTopic = defaultTopic + "/" + encoder.ProtocolSuffixSSZSnappy @@ -927,10 +927,10 @@ func TestValidateSyncContributionAndProof(t *testing.T) { WithOperationNotifier(chainService.OperationNotifier()), ) go s.verifierRoutine() - s.cfg.stateGen = stategen.New(db) + s.cfg.stateGen = stategen.New(database) msg.Message.Contribution.BlockRoot = headRoot[:] - s.cfg.beaconDB = db - hState, err := db.State(context.Background(), headRoot) + s.cfg.beaconDB = database + hState, err := database.State(context.Background(), headRoot) assert.NoError(t, err) sc, err := hState.CurrentSyncCommittee() assert.NoError(t, err) @@ -996,7 +996,7 @@ func TestValidateSyncContributionAndProof(t *testing.T) { assert.NoError(t, err) marshalledObj = snappy.Encode(nil, marshalledObj) pubsubMsg := &pubsub.Message{ - Message: &pubsub_pb.Message{ + Message: &pubsubpb.Message{ Data: marshalledObj, Topic: &defaultTopic, }, @@ -1049,7 +1049,7 @@ func TestValidateSyncContributionAndProof_Optimistic(t *testing.T) { topic := p2p.GossipTypeMapping[reflect.TypeOf(slashing)] msg := &pubsub.Message{ - Message: &pubsub_pb.Message{ + Message: &pubsubpb.Message{ Data: buf.Bytes(), Topic: &topic, }, diff --git a/beacon-chain/sync/validate_voluntary_exit_test.go b/beacon-chain/sync/validate_voluntary_exit_test.go index bb6e393686..afe38cd149 100644 --- a/beacon-chain/sync/validate_voluntary_exit_test.go +++ b/beacon-chain/sync/validate_voluntary_exit_test.go @@ -41,7 +41,7 @@ func setupValidExit(t *testing.T) (*ethpb.SignedVoluntaryExit, state.BeaconState ActivationEpoch: 0, }, } - state, err := v1.InitializeFromProto(ðpb.BeaconState{ + st, err := v1.InitializeFromProto(ðpb.BeaconState{ Validators: registry, Fork: ðpb.Fork{ CurrentVersion: params.BeaconConfig().GenesisForkVersion, @@ -50,24 +50,24 @@ func setupValidExit(t *testing.T) (*ethpb.SignedVoluntaryExit, state.BeaconState Slot: params.BeaconConfig().SlotsPerEpoch * 5, }) require.NoError(t, err) - err = state.SetSlot(state.Slot() + params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod))) + err = st.SetSlot(st.Slot() + params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod))) require.NoError(t, err) priv, err := bls.RandKey() require.NoError(t, err) - exit.Signature, err = signing.ComputeDomainAndSign(state, coreTime.CurrentEpoch(state), exit.Exit, params.BeaconConfig().DomainVoluntaryExit, priv) + exit.Signature, err = signing.ComputeDomainAndSign(st, coreTime.CurrentEpoch(st), exit.Exit, params.BeaconConfig().DomainVoluntaryExit, priv) require.NoError(t, err) - val, err := state.ValidatorAtIndex(0) + val, err := st.ValidatorAtIndex(0) require.NoError(t, err) val.PublicKey = priv.PublicKey().Marshal() - require.NoError(t, state.UpdateValidatorAtIndex(0, val)) + require.NoError(t, st.UpdateValidatorAtIndex(0, val)) b := make([]byte, 32) _, err = rand.Read(b) require.NoError(t, err) - return exit, state + return exit, st } func TestValidateVoluntaryExit_ValidExit(t *testing.T) { diff --git a/cmd/validator/accounts/delete_test.go b/cmd/validator/accounts/delete_test.go index 807cb86f1b..f53e597e1f 100644 --- a/cmd/validator/accounts/delete_test.go +++ b/cmd/validator/accounts/delete_test.go @@ -175,7 +175,7 @@ func TestDeleteAccounts_Noninteractive(t *testing.T) { // We attempt to delete the accounts specified. require.NoError(t, accountsDelete(cliCtx)) - keymanager, err := local.NewKeymanager( + km, err := local.NewKeymanager( cliCtx.Context, &local.SetupConfig{ Wallet: w, @@ -183,7 +183,7 @@ func TestDeleteAccounts_Noninteractive(t *testing.T) { }, ) require.NoError(t, err) - remainingAccounts, err := keymanager.FetchValidatingPublicKeys(cliCtx.Context) + remainingAccounts, err := km.FetchValidatingPublicKeys(cliCtx.Context) require.NoError(t, err) require.Equal(t, len(remainingAccounts), 1) remainingPublicKey, err := hex.DecodeString(k3.Pubkey) diff --git a/cmd/validator/accounts/exit_test.go b/cmd/validator/accounts/exit_test.go index 1b876b09d7..2584ff72b7 100644 --- a/cmd/validator/accounts/exit_test.go +++ b/cmd/validator/accounts/exit_test.go @@ -77,11 +77,11 @@ func TestExitAccountsCli_OK(t *testing.T) { require.NoError(t, err) require.NoError(t, accountsImport(cliCtx)) - _, keymanager, err := walletWithKeymanager(cliCtx) + _, km, err := walletWithKeymanager(cliCtx) require.NoError(t, err) - require.NotNil(t, keymanager) + require.NotNil(t, km) - validatingPublicKeys, err := keymanager.FetchValidatingPublicKeys(cliCtx.Context) + validatingPublicKeys, err := km.FetchValidatingPublicKeys(cliCtx.Context) require.NoError(t, err) require.NotNil(t, validatingPublicKeys) @@ -98,7 +98,7 @@ func TestExitAccountsCli_OK(t *testing.T) { cfg := accounts.PerformExitCfg{ ValidatorClient: mockValidatorClient, NodeClient: mockNodeClient, - Keymanager: keymanager, + Keymanager: km, RawPubKeys: rawPubKeys, FormattedPubKeys: formattedPubKeys, } @@ -177,11 +177,11 @@ func TestExitAccountsCli_OK_AllPublicKeys(t *testing.T) { require.NoError(t, err) require.NoError(t, accountsImport(cliCtx)) - _, keymanager, err := walletWithKeymanager(cliCtx) + _, km, err := walletWithKeymanager(cliCtx) require.NoError(t, err) - require.NotNil(t, keymanager) + require.NotNil(t, km) - validatingPublicKeys, err := keymanager.FetchValidatingPublicKeys(cliCtx.Context) + validatingPublicKeys, err := km.FetchValidatingPublicKeys(cliCtx.Context) require.NoError(t, err) require.NotNil(t, validatingPublicKeys) @@ -198,7 +198,7 @@ func TestExitAccountsCli_OK_AllPublicKeys(t *testing.T) { cfg := accounts.PerformExitCfg{ ValidatorClient: mockValidatorClient, NodeClient: mockNodeClient, - Keymanager: keymanager, + Keymanager: km, RawPubKeys: rawPubKeys, FormattedPubKeys: formattedPubKeys, } diff --git a/cmd/validator/accounts/import_test.go b/cmd/validator/accounts/import_test.go index 6b67afdda6..9c0a94b7cc 100644 --- a/cmd/validator/accounts/import_test.go +++ b/cmd/validator/accounts/import_test.go @@ -44,7 +44,7 @@ func TestImport_Noninteractive(t *testing.T) { }, }) require.NoError(t, err) - keymanager, err := local.NewKeymanager( + newKm, err := local.NewKeymanager( cliCtx.Context, &local.SetupConfig{ Wallet: w, @@ -54,9 +54,9 @@ func TestImport_Noninteractive(t *testing.T) { require.NoError(t, err) // Make sure there are no accounts at the start. - accounts, err := keymanager.ValidatingAccountNames() + accNames, err := newKm.ValidatingAccountNames() require.NoError(t, err) - assert.Equal(t, len(accounts), 0) + assert.Equal(t, len(accNames), 0) // Create 2 keys. createKeystore(t, keysDir) @@ -149,7 +149,7 @@ func TestImport_Noninteractive_RandomName(t *testing.T) { }, }) require.NoError(t, err) - keymanager, err := local.NewKeymanager( + newKm, err := local.NewKeymanager( cliCtx.Context, &local.SetupConfig{ Wallet: w, @@ -159,9 +159,9 @@ func TestImport_Noninteractive_RandomName(t *testing.T) { require.NoError(t, err) // Make sure there are no accounts at the start. - accounts, err := keymanager.ValidatingAccountNames() + accNames, err := newKm.ValidatingAccountNames() require.NoError(t, err) - assert.Equal(t, len(accounts), 0) + assert.Equal(t, len(accNames), 0) // Create 2 keys. createRandomNameKeystore(t, keysDir) @@ -232,7 +232,7 @@ func TestImport_Noninteractive_Filepath(t *testing.T) { }, }) require.NoError(t, err) - keymanager, err := local.NewKeymanager( + newKm, err := local.NewKeymanager( cliCtx.Context, &local.SetupConfig{ Wallet: w, @@ -242,9 +242,9 @@ func TestImport_Noninteractive_Filepath(t *testing.T) { require.NoError(t, err) // Make sure there are no accounts at the start. - accounts, err := keymanager.ValidatingAccountNames() + accNames, err := newKm.ValidatingAccountNames() require.NoError(t, err) - assert.Equal(t, len(accounts), 0) + assert.Equal(t, len(accNames), 0) require.NoError(t, accountsImport(cliCtx)) diff --git a/config/params/loader_test.go b/config/params/loader_test.go index 9b1a9d4b47..df9d7e5e40 100644 --- a/config/params/loader_test.go +++ b/config/params/loader_test.go @@ -158,12 +158,12 @@ func TestLoadConfigFile(t *testing.T) { } func TestLoadConfigFile_OverwriteCorrectly(t *testing.T) { - file, err := os.CreateTemp("", "") + f, err := os.CreateTemp("", "") require.NoError(t, err) // Set current config to minimal config cfg := params.MinimalSpecConfig().Copy() params.FillTestVersions(cfg, 128) - _, err = io.Copy(file, bytes.NewBuffer(params.ConfigToYaml(cfg))) + _, err = io.Copy(f, bytes.NewBuffer(params.ConfigToYaml(cfg))) require.NoError(t, err) // set active config to mainnet, so that we can confirm LoadChainConfigFile overrides it @@ -177,7 +177,7 @@ func TestLoadConfigFile_OverwriteCorrectly(t *testing.T) { }() // load empty config file, so that it defaults to mainnet values - require.NoError(t, params.LoadChainConfigFile(file.Name(), nil)) + require.NoError(t, params.LoadChainConfigFile(f.Name(), nil)) if params.BeaconConfig().MinGenesisTime != cfg.MinGenesisTime { t.Errorf("Expected MinGenesisTime to be set to value written to config: %d found: %d", cfg.MinGenesisTime, @@ -276,9 +276,9 @@ func TestConfigParityYaml(t *testing.T) { // configFilePath sets the proper config and returns the relevant // config file path from eth2-spec-tests directory. func configFilePath(t *testing.T, config string) string { - filepath, err := bazel.Runfile("external/consensus_spec") + fPath, err := bazel.Runfile("external/consensus_spec") require.NoError(t, err) - configFilePath := path.Join(filepath, "configs", config+".yaml") + configFilePath := path.Join(fPath, "configs", config+".yaml") return configFilePath } @@ -286,11 +286,11 @@ func configFilePath(t *testing.T, config string) string { // directory. This method returns a preset file path for each hard fork or // major network upgrade, in order. func presetsFilePath(t *testing.T, config string) []string { - filepath, err := bazel.Runfile("external/consensus_spec") + fPath, err := bazel.Runfile("external/consensus_spec") require.NoError(t, err) return []string{ - path.Join(filepath, "presets", config, "phase0.yaml"), - path.Join(filepath, "presets", config, "altair.yaml"), + path.Join(fPath, "presets", config, "phase0.yaml"), + path.Join(fPath, "presets", config, "altair.yaml"), } } diff --git a/config/params/testnet_config_test.go b/config/params/testnet_config_test.go index 3b2db4398c..26f329d79e 100644 --- a/config/params/testnet_config_test.go +++ b/config/params/testnet_config_test.go @@ -13,9 +13,9 @@ import ( ) func testnetConfigFilePath(t *testing.T, network string) string { - filepath, err := bazel.Runfile("external/eth2_networks") + fPath, err := bazel.Runfile("external/eth2_networks") require.NoError(t, err) - configFilePath := path.Join(filepath, "shared", network, "config.yaml") + configFilePath := path.Join(fPath, "shared", network, "config.yaml") return configFilePath } diff --git a/config/validator/service/proposer-settings.go b/config/validator/service/proposer-settings.go index be19b6f8bd..626a3bd1b2 100644 --- a/config/validator/service/proposer-settings.go +++ b/config/validator/service/proposer-settings.go @@ -2,7 +2,7 @@ package validator_service_config import ( "github.com/ethereum/go-ethereum/common" - field_params "github.com/prysmaticlabs/prysm/config/fieldparams" + fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams" "github.com/prysmaticlabs/prysm/config/params" ) @@ -25,7 +25,7 @@ type ProposerOptionPayload struct { // ProposerSettings is a Prysm internal representation of the fee recipient config on the validator client. // ProposerSettingsPayload maps to ProposerSettings on import through the CLI. type ProposerSettings struct { - ProposeConfig map[[field_params.BLSPubkeyLength]byte]*ProposerOption + ProposeConfig map[[fieldparams.BLSPubkeyLength]byte]*ProposerOption DefaultConfig *ProposerOption } diff --git a/consensus-types/forks/bellatrix/execution_payload.go b/consensus-types/forks/bellatrix/execution_payload.go index 4be4fddbd6..e53dac1bcd 100644 --- a/consensus-types/forks/bellatrix/execution_payload.go +++ b/consensus-types/forks/bellatrix/execution_payload.go @@ -3,7 +3,7 @@ package bellatrix import ( "bytes" - field_params "github.com/prysmaticlabs/prysm/config/fieldparams" + fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams" "github.com/prysmaticlabs/prysm/encoding/bytesutil" "github.com/prysmaticlabs/prysm/encoding/ssz" enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1" @@ -38,28 +38,28 @@ func IsEmptyPayload(p *enginev1.ExecutionPayload) bool { if p == nil { return true } - if !bytes.Equal(p.ParentHash, make([]byte, field_params.RootLength)) { + if !bytes.Equal(p.ParentHash, make([]byte, fieldparams.RootLength)) { return false } - if !bytes.Equal(p.FeeRecipient, make([]byte, field_params.FeeRecipientLength)) { + if !bytes.Equal(p.FeeRecipient, make([]byte, fieldparams.FeeRecipientLength)) { return false } - if !bytes.Equal(p.StateRoot, make([]byte, field_params.RootLength)) { + if !bytes.Equal(p.StateRoot, make([]byte, fieldparams.RootLength)) { return false } - if !bytes.Equal(p.ReceiptsRoot, make([]byte, field_params.RootLength)) { + if !bytes.Equal(p.ReceiptsRoot, make([]byte, fieldparams.RootLength)) { return false } - if !bytes.Equal(p.LogsBloom, make([]byte, field_params.LogsBloomLength)) { + if !bytes.Equal(p.LogsBloom, make([]byte, fieldparams.LogsBloomLength)) { return false } - if !bytes.Equal(p.PrevRandao, make([]byte, field_params.RootLength)) { + if !bytes.Equal(p.PrevRandao, make([]byte, fieldparams.RootLength)) { return false } - if !bytes.Equal(p.BaseFeePerGas, make([]byte, field_params.RootLength)) { + if !bytes.Equal(p.BaseFeePerGas, make([]byte, fieldparams.RootLength)) { return false } - if !bytes.Equal(p.BlockHash, make([]byte, field_params.RootLength)) { + if !bytes.Equal(p.BlockHash, make([]byte, fieldparams.RootLength)) { return false } if len(p.Transactions) != 0 { @@ -84,31 +84,31 @@ func IsEmptyPayload(p *enginev1.ExecutionPayload) bool { } func IsEmptyHeader(h *enginev1.ExecutionPayloadHeader) bool { - if !bytes.Equal(h.ParentHash, make([]byte, field_params.RootLength)) { + if !bytes.Equal(h.ParentHash, make([]byte, fieldparams.RootLength)) { return false } - if !bytes.Equal(h.FeeRecipient, make([]byte, field_params.FeeRecipientLength)) { + if !bytes.Equal(h.FeeRecipient, make([]byte, fieldparams.FeeRecipientLength)) { return false } - if !bytes.Equal(h.StateRoot, make([]byte, field_params.RootLength)) { + if !bytes.Equal(h.StateRoot, make([]byte, fieldparams.RootLength)) { return false } - if !bytes.Equal(h.ReceiptsRoot, make([]byte, field_params.RootLength)) { + if !bytes.Equal(h.ReceiptsRoot, make([]byte, fieldparams.RootLength)) { return false } - if !bytes.Equal(h.LogsBloom, make([]byte, field_params.LogsBloomLength)) { + if !bytes.Equal(h.LogsBloom, make([]byte, fieldparams.LogsBloomLength)) { return false } - if !bytes.Equal(h.PrevRandao, make([]byte, field_params.RootLength)) { + if !bytes.Equal(h.PrevRandao, make([]byte, fieldparams.RootLength)) { return false } - if !bytes.Equal(h.BaseFeePerGas, make([]byte, field_params.RootLength)) { + if !bytes.Equal(h.BaseFeePerGas, make([]byte, fieldparams.RootLength)) { return false } - if !bytes.Equal(h.BlockHash, make([]byte, field_params.RootLength)) { + if !bytes.Equal(h.BlockHash, make([]byte, fieldparams.RootLength)) { return false } - if !bytes.Equal(h.TransactionsRoot, make([]byte, field_params.RootLength)) { + if !bytes.Equal(h.TransactionsRoot, make([]byte, fieldparams.RootLength)) { return false } if len(h.ExtraData) != 0 { diff --git a/consensus-types/primitives/domain.go b/consensus-types/primitives/domain.go index 685ee3c740..ec4d98747f 100644 --- a/consensus-types/primitives/domain.go +++ b/consensus-types/primitives/domain.go @@ -14,32 +14,32 @@ var _ fssz.Unmarshaler = (*Domain)(nil) type Domain []byte // HashTreeRoot -- -func (e Domain) HashTreeRoot() ([32]byte, error) { - return fssz.HashWithDefaultHasher(e) +func (d Domain) HashTreeRoot() ([32]byte, error) { + return fssz.HashWithDefaultHasher(d) } // HashTreeRootWith -- -func (e Domain) HashTreeRootWith(hh *fssz.Hasher) error { - hh.PutBytes(e[:]) +func (d Domain) HashTreeRootWith(hh *fssz.Hasher) error { + hh.PutBytes(d[:]) return nil } // UnmarshalSSZ -- -func (e *Domain) UnmarshalSSZ(buf []byte) error { - if len(buf) != e.SizeSSZ() { - return fmt.Errorf("expected buffer of length %d received %d", e.SizeSSZ(), len(buf)) +func (d *Domain) UnmarshalSSZ(buf []byte) error { + if len(buf) != d.SizeSSZ() { + return fmt.Errorf("expected buffer of length %d received %d", d.SizeSSZ(), len(buf)) } var b [32]byte item := Domain(b[:]) copy(item, buf) - *e = item + *d = item return nil } // MarshalSSZTo -- -func (e *Domain) MarshalSSZTo(dst []byte) ([]byte, error) { - marshalled, err := e.MarshalSSZ() +func (d *Domain) MarshalSSZTo(dst []byte) ([]byte, error) { + marshalled, err := d.MarshalSSZ() if err != nil { return nil, err } @@ -47,11 +47,11 @@ func (e *Domain) MarshalSSZTo(dst []byte) ([]byte, error) { } // MarshalSSZ -- -func (e *Domain) MarshalSSZ() ([]byte, error) { - return *e, nil +func (d *Domain) MarshalSSZ() ([]byte, error) { + return *d, nil } // SizeSSZ -- -func (e *Domain) SizeSSZ() int { +func (_ *Domain) SizeSSZ() int { return 32 } diff --git a/consensus-types/primitives/slot.go b/consensus-types/primitives/slot.go index 114f2826da..c027e9de7f 100644 --- a/consensus-types/primitives/slot.go +++ b/consensus-types/primitives/slot.go @@ -1,7 +1,7 @@ package types import ( - fmt "fmt" + "fmt" fssz "github.com/ferranbt/fastssz" "github.com/prysmaticlabs/prysm/math" diff --git a/consensus-types/primitives/validator.go b/consensus-types/primitives/validator.go index 0dd94eac62..cd7a955681 100644 --- a/consensus-types/primitives/validator.go +++ b/consensus-types/primitives/validator.go @@ -1,7 +1,7 @@ package types import ( - fmt "fmt" + "fmt" fssz "github.com/ferranbt/fastssz" ) diff --git a/container/trie/sparse_merkle_test.go b/container/trie/sparse_merkle_test.go index 7d362431b5..2cec541e1f 100644 --- a/container/trie/sparse_merkle_test.go +++ b/container/trie/sparse_merkle_test.go @@ -135,14 +135,14 @@ func TestMerkleTrie_MerkleProofOutOfRange(t *testing.T) { } func TestMerkleTrieRoot_EmptyTrie(t *testing.T) { - trie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) + newTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) require.NoError(t, err) testAccount, err := contracts.Setup() require.NoError(t, err) depRoot, err := testAccount.Contract.GetDepositRoot(&bind.CallOpts{}) require.NoError(t, err) - root, err := trie.HashTreeRoot() + root, err := newTrie.HashTreeRoot() require.NoError(t, err) require.DeepEqual(t, depRoot, root) } diff --git a/io/file/fileutil_test.go b/io/file/fileutil_test.go index 6a3de91699..41ab934b45 100644 --- a/io/file/fileutil_test.go +++ b/io/file/fileutil_test.go @@ -31,11 +31,11 @@ import ( ) func TestPathExpansion(t *testing.T) { - user, err := user.Current() + u, err := user.Current() require.NoError(t, err) tests := map[string]string{ "/home/someuser/tmp": "/home/someuser/tmp", - "~/tmp": user.HomeDir + "/tmp", + "~/tmp": u.HomeDir + "/tmp", "$DDDXXX/a/b": "/tmp/a/b", "/a/b/": "/a/b", } diff --git a/runtime/interop/generate_genesis_state.go b/runtime/interop/generate_genesis_state.go index 3bdfba2fc5..87b652ed87 100644 --- a/runtime/interop/generate_genesis_state.go +++ b/runtime/interop/generate_genesis_state.go @@ -10,7 +10,7 @@ import ( "github.com/prysmaticlabs/prysm/async" "github.com/prysmaticlabs/prysm/beacon-chain/core/signing" coreState "github.com/prysmaticlabs/prysm/beacon-chain/core/transition" - state_native "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native" + statenative "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native" v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1" "github.com/prysmaticlabs/prysm/config/features" "github.com/prysmaticlabs/prysm/config/params" @@ -46,15 +46,15 @@ func GenerateGenesisState(ctx context.Context, genesisTime, numValidators uint64 func GenerateGenesisStateFromDepositData( ctx context.Context, genesisTime uint64, depositData []*ethpb.Deposit_Data, depositDataRoots [][]byte, ) (*ethpb.BeaconState, []*ethpb.Deposit, error) { - trie, err := trie.GenerateTrieFromItems(depositDataRoots, params.BeaconConfig().DepositContractTreeDepth) + t, err := trie.GenerateTrieFromItems(depositDataRoots, params.BeaconConfig().DepositContractTreeDepth) if err != nil { return nil, nil, errors.Wrap(err, "could not generate Merkle trie for deposit proofs") } - deposits, err := GenerateDepositsFromData(depositData, trie) + deposits, err := GenerateDepositsFromData(depositData, t) if err != nil { return nil, nil, errors.Wrap(err, "could not generate deposits from the deposit data provided") } - root, err := trie.HashTreeRoot() + root, err := t.HashTreeRoot() if err != nil { return nil, nil, errors.Wrap(err, "could not hash tree root of deposit trie") } @@ -72,7 +72,7 @@ func GenerateGenesisStateFromDepositData( var pbState *ethpb.BeaconState if features.Get().EnableNativeState { - pbState, err = state_native.ProtobufBeaconStatePhase0(beaconState.InnerStateUnsafe()) + pbState, err = statenative.ProtobufBeaconStatePhase0(beaconState.InnerStateUnsafe()) } else { pbState, err = v1.ProtobufBeaconState(beaconState.InnerStateUnsafe()) } @@ -151,11 +151,11 @@ func depositDataFromKeys(privKeys []bls.SecretKey, pubKeys []bls.PublicKey) ([]* if err != nil { return nil, nil, errors.Wrapf(err, "could not create deposit data for key: %#x", privKeys[i].Marshal()) } - hash, err := data.HashTreeRoot() + h, err := data.HashTreeRoot() if err != nil { return nil, nil, errors.Wrap(err, "could not hash tree root deposit data item") } - dataRoots[i] = hash[:] + dataRoots[i] = h[:] depositDataItems[i] = data } return depositDataItems, dataRoots, nil diff --git a/runtime/interop/generate_keys.go b/runtime/interop/generate_keys.go index ba3274f471..6b755e22a9 100644 --- a/runtime/interop/generate_keys.go +++ b/runtime/interop/generate_keys.go @@ -52,9 +52,9 @@ func deterministicallyGenerateKeys(startIndex, numKeys uint64) ([]bls.SecretKey, for i := startIndex; i < startIndex+numKeys; i++ { enc := make([]byte, 32) binary.LittleEndian.PutUint32(enc, uint32(i)) - hash := hash.Hash(enc) + h := hash.Hash(enc) // Reverse byte order to big endian for use with big ints. - b := bytesutil.ReverseByteOrder(hash[:]) + b := bytesutil.ReverseByteOrder(h[:]) num := new(big.Int) num = num.SetBytes(b) order := new(big.Int) diff --git a/testing/endtoend/components/eth1/proxy.go b/testing/endtoend/components/eth1/proxy.go index 1454ab9cbe..0470de40e9 100644 --- a/testing/endtoend/components/eth1/proxy.go +++ b/testing/endtoend/components/eth1/proxy.go @@ -137,7 +137,7 @@ func NewProxy(index int) *Proxy { // Start runs a proxy. func (node *Proxy) Start(ctx context.Context) error { - file, err := os.Create(path.Join(e2e.TestParams.LogPath, "eth1_proxy_"+strconv.Itoa(node.index)+".log")) + f, err := os.Create(path.Join(e2e.TestParams.LogPath, "eth1_proxy_"+strconv.Itoa(node.index)+".log")) if err != nil { return err } @@ -154,14 +154,14 @@ func (node *Proxy) Start(ctx context.Context) error { proxy.WithDestinationAddress(fmt.Sprintf("http://127.0.0.1:%d", e2e.TestParams.Ports.Eth1AuthRPCPort+node.index)), proxy.WithPort(e2e.TestParams.Ports.Eth1ProxyPort + node.index), proxy.WithLogger(log.New()), - proxy.WithLogFile(file), + proxy.WithLogFile(f), proxy.WithJwtSecret(string(secret)), } nProxy, err := proxy.New(opts...) if err != nil { return err } - log.Infof("Starting eth1 proxy %d with port: %d and file %s", node.index, e2e.TestParams.Ports.Eth1ProxyPort+node.index, file.Name()) + log.Infof("Starting eth1 proxy %d with port: %d and file %s", node.index, e2e.TestParams.Ports.Eth1ProxyPort+node.index, f.Name()) // Set cancel into context. ctx, cancel := context.WithCancel(ctx) diff --git a/testing/endtoend/components/lighthouse_validator.go b/testing/endtoend/components/lighthouse_validator.go index d5921c7f68..f8ff7e9fe1 100644 --- a/testing/endtoend/components/lighthouse_validator.go +++ b/testing/endtoend/components/lighthouse_validator.go @@ -255,7 +255,7 @@ func NewKeystoreGenerator() *KeystoreGenerator { return &KeystoreGenerator{started: make(chan struct{})} } -func (k *KeystoreGenerator) Start(ctx context.Context) error { +func (k *KeystoreGenerator) Start(_ context.Context) error { validatorNum := int(params.BeaconConfig().MinGenesisActiveValidatorCount) lighthouseBeaconNum := e2e.TestParams.LighthouseBeaconNodeCount prysmBeaconNum := e2e.TestParams.BeaconNodeCount diff --git a/testing/endtoend/types/types.go b/testing/endtoend/types/types.go index 6a00b0dd22..46ca843904 100644 --- a/testing/endtoend/types/types.go +++ b/testing/endtoend/types/types.go @@ -11,12 +11,6 @@ import ( type E2EConfigOpt func(*E2EConfig) -func WithExtraEpochs(extra uint64) E2EConfigOpt { - return func(cfg *E2EConfig) { - cfg.ExtraEpochs = extra - } -} - func WithEpochs(e uint64) E2EConfigOpt { return func(cfg *E2EConfig) { cfg.EpochsToRun = e diff --git a/testing/middleware/engine-api-proxy/proxy_test.go b/testing/middleware/engine-api-proxy/proxy_test.go index 3bb7e526a0..de3fd346c6 100644 --- a/testing/middleware/engine-api-proxy/proxy_test.go +++ b/testing/middleware/engine-api-proxy/proxy_test.go @@ -260,9 +260,6 @@ func TestProxy_CustomInterceptors(t *testing.T) { } func Test_isEngineAPICall(t *testing.T) { - type args struct { - reqBytes []byte - } tests := []struct { name string args *jsonRPCObject diff --git a/testing/spectest/shared/altair/epoch_processing/effective_balance_updates.go b/testing/spectest/shared/altair/epoch_processing/effective_balance_updates.go index 86eae0b877..294459802c 100644 --- a/testing/spectest/shared/altair/epoch_processing/effective_balance_updates.go +++ b/testing/spectest/shared/altair/epoch_processing/effective_balance_updates.go @@ -23,8 +23,8 @@ func RunEffectiveBalanceUpdatesTests(t *testing.T, config string) { } } -func processEffectiveBalanceUpdatesWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessEffectiveBalanceUpdates(state) +func processEffectiveBalanceUpdatesWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessEffectiveBalanceUpdates(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/altair/epoch_processing/eth1_data_reset.go b/testing/spectest/shared/altair/epoch_processing/eth1_data_reset.go index 661e4f7efe..995062baa5 100644 --- a/testing/spectest/shared/altair/epoch_processing/eth1_data_reset.go +++ b/testing/spectest/shared/altair/epoch_processing/eth1_data_reset.go @@ -23,8 +23,8 @@ func RunEth1DataResetTests(t *testing.T, config string) { } } -func processEth1DataResetWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessEth1DataReset(state) +func processEth1DataResetWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessEth1DataReset(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/altair/epoch_processing/historical_roots_update.go b/testing/spectest/shared/altair/epoch_processing/historical_roots_update.go index 894f1f5da8..d842d04152 100644 --- a/testing/spectest/shared/altair/epoch_processing/historical_roots_update.go +++ b/testing/spectest/shared/altair/epoch_processing/historical_roots_update.go @@ -23,8 +23,8 @@ func RunHistoricalRootsUpdateTests(t *testing.T, config string) { } } -func processHistoricalRootsUpdateWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessHistoricalRootsUpdate(state) +func processHistoricalRootsUpdateWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessHistoricalRootsUpdate(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/altair/epoch_processing/participation_flag_updates.go b/testing/spectest/shared/altair/epoch_processing/participation_flag_updates.go index 6332c88896..f616b47346 100644 --- a/testing/spectest/shared/altair/epoch_processing/participation_flag_updates.go +++ b/testing/spectest/shared/altair/epoch_processing/participation_flag_updates.go @@ -23,8 +23,8 @@ func RunParticipationFlagUpdatesTests(t *testing.T, config string) { } } -func processParticipationFlagUpdatesWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := altair.ProcessParticipationFlagUpdates(state) +func processParticipationFlagUpdatesWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := altair.ProcessParticipationFlagUpdates(st) require.NoError(t, err, "Could not process participation flag update") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/altair/epoch_processing/randao_mixes_reset.go b/testing/spectest/shared/altair/epoch_processing/randao_mixes_reset.go index a7cfb8020f..589a13e0c8 100644 --- a/testing/spectest/shared/altair/epoch_processing/randao_mixes_reset.go +++ b/testing/spectest/shared/altair/epoch_processing/randao_mixes_reset.go @@ -23,8 +23,8 @@ func RunRandaoMixesResetTests(t *testing.T, config string) { } } -func processRandaoMixesResetWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessRandaoMixesReset(state) +func processRandaoMixesResetWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessRandaoMixesReset(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/altair/epoch_processing/slashings.go b/testing/spectest/shared/altair/epoch_processing/slashings.go index 617eca09b7..0e1fab9abe 100644 --- a/testing/spectest/shared/altair/epoch_processing/slashings.go +++ b/testing/spectest/shared/altair/epoch_processing/slashings.go @@ -26,8 +26,8 @@ func RunSlashingsTests(t *testing.T, config string) { } } -func processSlashingsWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessSlashings(state, params.BeaconConfig().ProportionalSlashingMultiplierAltair) +func processSlashingsWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessSlashings(st, params.BeaconConfig().ProportionalSlashingMultiplierAltair) require.NoError(t, err, "Could not process slashings") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/altair/epoch_processing/slashings_reset.go b/testing/spectest/shared/altair/epoch_processing/slashings_reset.go index 459925f3d4..197f534b01 100644 --- a/testing/spectest/shared/altair/epoch_processing/slashings_reset.go +++ b/testing/spectest/shared/altair/epoch_processing/slashings_reset.go @@ -23,8 +23,8 @@ func RunSlashingsResetTests(t *testing.T, config string) { } } -func processSlashingsResetWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessSlashingsReset(state) +func processSlashingsResetWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessSlashingsReset(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/bellatrix/epoch_processing/effective_balance_updates.go b/testing/spectest/shared/bellatrix/epoch_processing/effective_balance_updates.go index 33a0e9228d..3bd765171f 100644 --- a/testing/spectest/shared/bellatrix/epoch_processing/effective_balance_updates.go +++ b/testing/spectest/shared/bellatrix/epoch_processing/effective_balance_updates.go @@ -23,8 +23,8 @@ func RunEffectiveBalanceUpdatesTests(t *testing.T, config string) { } } -func processEffectiveBalanceUpdatesWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessEffectiveBalanceUpdates(state) +func processEffectiveBalanceUpdatesWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessEffectiveBalanceUpdates(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/bellatrix/epoch_processing/eth1_data_reset.go b/testing/spectest/shared/bellatrix/epoch_processing/eth1_data_reset.go index 4d4dc98d00..88cc759ded 100644 --- a/testing/spectest/shared/bellatrix/epoch_processing/eth1_data_reset.go +++ b/testing/spectest/shared/bellatrix/epoch_processing/eth1_data_reset.go @@ -23,8 +23,8 @@ func RunEth1DataResetTests(t *testing.T, config string) { } } -func processEth1DataResetWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessEth1DataReset(state) +func processEth1DataResetWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessEth1DataReset(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/bellatrix/epoch_processing/historical_roots_update.go b/testing/spectest/shared/bellatrix/epoch_processing/historical_roots_update.go index 8a9fea0d8b..272df844c6 100644 --- a/testing/spectest/shared/bellatrix/epoch_processing/historical_roots_update.go +++ b/testing/spectest/shared/bellatrix/epoch_processing/historical_roots_update.go @@ -23,8 +23,8 @@ func RunHistoricalRootsUpdateTests(t *testing.T, config string) { } } -func processHistoricalRootsUpdateWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessHistoricalRootsUpdate(state) +func processHistoricalRootsUpdateWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessHistoricalRootsUpdate(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/bellatrix/epoch_processing/participation_flag_updates.go b/testing/spectest/shared/bellatrix/epoch_processing/participation_flag_updates.go index bb77cda148..8eb8bdae26 100644 --- a/testing/spectest/shared/bellatrix/epoch_processing/participation_flag_updates.go +++ b/testing/spectest/shared/bellatrix/epoch_processing/participation_flag_updates.go @@ -23,8 +23,8 @@ func RunParticipationFlagUpdatesTests(t *testing.T, config string) { } } -func processParticipationFlagUpdatesWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := altair.ProcessParticipationFlagUpdates(state) +func processParticipationFlagUpdatesWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := altair.ProcessParticipationFlagUpdates(st) require.NoError(t, err, "Could not process participation flag update") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/bellatrix/epoch_processing/randao_mixes_reset.go b/testing/spectest/shared/bellatrix/epoch_processing/randao_mixes_reset.go index dbfcebcbc4..e6a0166adf 100644 --- a/testing/spectest/shared/bellatrix/epoch_processing/randao_mixes_reset.go +++ b/testing/spectest/shared/bellatrix/epoch_processing/randao_mixes_reset.go @@ -23,8 +23,8 @@ func RunRandaoMixesResetTests(t *testing.T, config string) { } } -func processRandaoMixesResetWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessRandaoMixesReset(state) +func processRandaoMixesResetWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessRandaoMixesReset(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/bellatrix/epoch_processing/slashings.go b/testing/spectest/shared/bellatrix/epoch_processing/slashings.go index 5414fc28cc..73487a3c1f 100644 --- a/testing/spectest/shared/bellatrix/epoch_processing/slashings.go +++ b/testing/spectest/shared/bellatrix/epoch_processing/slashings.go @@ -26,8 +26,8 @@ func RunSlashingsTests(t *testing.T, config string) { } } -func processSlashingsWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessSlashings(state, params.BeaconConfig().ProportionalSlashingMultiplierBellatrix) +func processSlashingsWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessSlashings(st, params.BeaconConfig().ProportionalSlashingMultiplierBellatrix) require.NoError(t, err, "Could not process slashings") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/bellatrix/epoch_processing/slashings_reset.go b/testing/spectest/shared/bellatrix/epoch_processing/slashings_reset.go index 61c36dc072..d64edf2d0b 100644 --- a/testing/spectest/shared/bellatrix/epoch_processing/slashings_reset.go +++ b/testing/spectest/shared/bellatrix/epoch_processing/slashings_reset.go @@ -23,8 +23,8 @@ func RunSlashingsResetTests(t *testing.T, config string) { } } -func processSlashingsResetWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessSlashingsReset(state) +func processSlashingsResetWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessSlashingsReset(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/bellatrix/fork/upgrade_to_bellatrix.go b/testing/spectest/shared/bellatrix/fork/upgrade_to_bellatrix.go index 3c7a46b8ac..7e4df1a33b 100644 --- a/testing/spectest/shared/bellatrix/fork/upgrade_to_bellatrix.go +++ b/testing/spectest/shared/bellatrix/fork/upgrade_to_bellatrix.go @@ -1,7 +1,6 @@ package fork import ( - "context" "path" "testing" @@ -38,7 +37,7 @@ func RunUpgradeToBellatrix(t *testing.T, config string) { } preState, err := v2.InitializeFromProto(preStateBase) require.NoError(t, err) - postState, err := execution.UpgradeToBellatrix(context.Background(), preState) + postState, err := execution.UpgradeToBellatrix(preState) require.NoError(t, err) postStateFromFunction, err := v3.ProtobufBeaconState(postState.InnerStateUnsafe()) require.NoError(t, err) diff --git a/testing/spectest/shared/common/forkchoice/builder.go b/testing/spectest/shared/common/forkchoice/builder.go index f8c1ad2891..923e033c35 100644 --- a/testing/spectest/shared/common/forkchoice/builder.go +++ b/testing/spectest/shared/common/forkchoice/builder.go @@ -65,7 +65,7 @@ func (bb *Builder) ValidBlock(t testing.TB, b interfaces.SignedBeaconBlock) { } // PoWBlock receives the block and notifies a mocked execution engine. -func (bb *Builder) PoWBlock(t testing.TB, pb *ethpb.PowBlock) { +func (bb *Builder) PoWBlock(pb *ethpb.PowBlock) { bb.execMock.powBlocks[bytesutil.ToBytes32(pb.BlockHash)] = pb } diff --git a/testing/spectest/shared/common/forkchoice/builder_test.go b/testing/spectest/shared/common/forkchoice/builder_test.go index 57165242b0..d4e9ac29a7 100644 --- a/testing/spectest/shared/common/forkchoice/builder_test.go +++ b/testing/spectest/shared/common/forkchoice/builder_test.go @@ -35,7 +35,7 @@ func TestPoWBlock(t *testing.T) { blk, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock()) require.NoError(t, err) builder := NewBuilder(t, st, blk) - builder.PoWBlock(t, ðpb.PowBlock{BlockHash: []byte{1, 2, 3}}) + builder.PoWBlock(ðpb.PowBlock{BlockHash: []byte{1, 2, 3}}) require.Equal(t, 1, len(builder.execMock.powBlocks)) } diff --git a/testing/spectest/shared/common/forkchoice/runner.go b/testing/spectest/shared/common/forkchoice/runner.go index 053ddd02c8..b3eac84a81 100644 --- a/testing/spectest/shared/common/forkchoice/runner.go +++ b/testing/spectest/shared/common/forkchoice/runner.go @@ -120,7 +120,7 @@ func Run(t *testing.T, config string, fork int) { require.NoError(t, err) pb := ðpb.PowBlock{} require.NoError(t, pb.UnmarshalSSZ(p), "Failed to unmarshal") - builder.PoWBlock(t, pb) + builder.PoWBlock(pb) } builder.Check(t, step.Check) } diff --git a/testing/spectest/shared/common/forkchoice/service.go b/testing/spectest/shared/common/forkchoice/service.go index fc4480bbf0..20b786bea9 100644 --- a/testing/spectest/shared/common/forkchoice/service.go +++ b/testing/spectest/shared/common/forkchoice/service.go @@ -79,7 +79,7 @@ func (m *engineMock) NewPayload(context.Context, *pb.ExecutionPayload) ([]byte, return nil, nil } -func (m *engineMock) LatestExecutionBlock(context.Context) (*pb.ExecutionBlock, error) { +func (m *engineMock) LatestExecutionBlock() (*pb.ExecutionBlock, error) { return nil, nil } diff --git a/testing/spectest/shared/phase0/epoch_processing/effective_balance_updates.go b/testing/spectest/shared/phase0/epoch_processing/effective_balance_updates.go index bfbc8c1ea5..2015bcf193 100644 --- a/testing/spectest/shared/phase0/epoch_processing/effective_balance_updates.go +++ b/testing/spectest/shared/phase0/epoch_processing/effective_balance_updates.go @@ -23,8 +23,8 @@ func RunEffectiveBalanceUpdatesTests(t *testing.T, config string) { } } -func processEffectiveBalanceUpdatesWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessEffectiveBalanceUpdates(state) +func processEffectiveBalanceUpdatesWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessEffectiveBalanceUpdates(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/phase0/epoch_processing/eth1_data_reset.go b/testing/spectest/shared/phase0/epoch_processing/eth1_data_reset.go index a65f5c8e4f..4bd284155e 100644 --- a/testing/spectest/shared/phase0/epoch_processing/eth1_data_reset.go +++ b/testing/spectest/shared/phase0/epoch_processing/eth1_data_reset.go @@ -23,8 +23,8 @@ func RunEth1DataResetTests(t *testing.T, config string) { } } -func processEth1DataResetWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessEth1DataReset(state) +func processEth1DataResetWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessEth1DataReset(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/phase0/epoch_processing/historical_roots_update.go b/testing/spectest/shared/phase0/epoch_processing/historical_roots_update.go index 54ee7862f9..bf31a4ff6b 100644 --- a/testing/spectest/shared/phase0/epoch_processing/historical_roots_update.go +++ b/testing/spectest/shared/phase0/epoch_processing/historical_roots_update.go @@ -23,8 +23,8 @@ func RunHistoricalRootsUpdateTests(t *testing.T, config string) { } } -func processHistoricalRootsUpdateWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessHistoricalRootsUpdate(state) +func processHistoricalRootsUpdateWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessHistoricalRootsUpdate(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/phase0/epoch_processing/participation_record_updates.go b/testing/spectest/shared/phase0/epoch_processing/participation_record_updates.go index 77c8971900..306c37b129 100644 --- a/testing/spectest/shared/phase0/epoch_processing/participation_record_updates.go +++ b/testing/spectest/shared/phase0/epoch_processing/participation_record_updates.go @@ -23,8 +23,8 @@ func RunParticipationRecordUpdatesTests(t *testing.T, config string) { } } -func processParticipationRecordUpdatesWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessParticipationRecordUpdates(state) +func processParticipationRecordUpdatesWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessParticipationRecordUpdates(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/phase0/epoch_processing/randao_mixes_reset.go b/testing/spectest/shared/phase0/epoch_processing/randao_mixes_reset.go index 1201f29acd..c10a153170 100644 --- a/testing/spectest/shared/phase0/epoch_processing/randao_mixes_reset.go +++ b/testing/spectest/shared/phase0/epoch_processing/randao_mixes_reset.go @@ -23,8 +23,8 @@ func RunRandaoMixesResetTests(t *testing.T, config string) { } } -func processRandaoMixesResetWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessRandaoMixesReset(state) +func processRandaoMixesResetWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessRandaoMixesReset(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/testing/spectest/shared/phase0/epoch_processing/slashings_reset.go b/testing/spectest/shared/phase0/epoch_processing/slashings_reset.go index 6d67bacd45..e05bd880ad 100644 --- a/testing/spectest/shared/phase0/epoch_processing/slashings_reset.go +++ b/testing/spectest/shared/phase0/epoch_processing/slashings_reset.go @@ -23,8 +23,8 @@ func RunSlashingsResetTests(t *testing.T, config string) { } } -func processSlashingsResetWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) { - state, err := epoch.ProcessSlashingsReset(state) +func processSlashingsResetWrapper(t *testing.T, st state.BeaconState) (state.BeaconState, error) { + st, err := epoch.ProcessSlashingsReset(st) require.NoError(t, err, "Could not process final updates") - return state, nil + return st, nil } diff --git a/tools/analyzers/gocognit/analyzer.go b/tools/analyzers/gocognit/analyzer.go index 9c5d016408..c69bfc0c08 100644 --- a/tools/analyzers/gocognit/analyzer.go +++ b/tools/analyzers/gocognit/analyzer.go @@ -34,7 +34,7 @@ var Analyzer = &analysis.Analyzer{ const over = 100 func run(pass *analysis.Pass) (interface{}, error) { - inspect, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector) + inspectResult, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector) if !ok { return nil, errors.New("analyzer is not type *inspector.Inspector") } @@ -42,7 +42,7 @@ func run(pass *analysis.Pass) (interface{}, error) { nodeFilter := []ast.Node{ (*ast.FuncDecl)(nil), } - inspect.Preorder(nodeFilter, func(n ast.Node) { + inspectResult.Preorder(nodeFilter, func(n ast.Node) { fnDecl, ok := n.(*ast.FuncDecl) if !ok { return diff --git a/tools/analyzers/recursivelock/analyzer.go b/tools/analyzers/recursivelock/analyzer.go index 6f649164db..6434515765 100644 --- a/tools/analyzers/recursivelock/analyzer.go +++ b/tools/analyzers/recursivelock/analyzer.go @@ -66,7 +66,7 @@ func (m mode) ErrorFound() error { } func run(pass *analysis.Pass) (interface{}, error) { - inspect, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector) + inspectResult, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector) if !ok { return nil, errors.New("analyzer is not type *inspector.Inspector") } @@ -86,7 +86,7 @@ func run(pass *analysis.Pass) (interface{}, error) { rLockTrack: &lockTracker{}, lockTrack: &lockTracker{}, } - inspect.Preorder(nodeFilter, func(node ast.Node) { + inspectResult.Preorder(nodeFilter, func(node ast.Node) { if keepTrackOf.rLockTrack.funcLitEnd.IsValid() && node.Pos() <= keepTrackOf.rLockTrack.funcLitEnd && keepTrackOf.lockTrack.funcLitEnd.IsValid() && node.Pos() <= keepTrackOf.lockTrack.funcLitEnd { return @@ -113,7 +113,7 @@ func run(pass *analysis.Pass) (interface{}, error) { keepTrackOf.lockTrack.retEnd = token.NoPos keepTrackOf.lockTrack.incFRU() } - keepTrackOf = stmtSelector(node, pass, keepTrackOf, inspect) + keepTrackOf = stmtSelector(node, pass, keepTrackOf, inspectResult) }) return nil, nil } @@ -418,7 +418,7 @@ func (s *selIdentList) changeRoot(r *ast.Ident, t types.Object) { } func (s selIdentList) String() (str string) { - var temp *selIdentNode = s.start + var temp = s.start str = fmt.Sprintf("length: %v\n[\n", s.length) for i := 0; temp != nil; i++ { if i == s.currentIndex { diff --git a/tools/blocktree/main.go b/tools/blocktree/main.go index f2a732fcde..4b5e8df654 100644 --- a/tools/blocktree/main.go +++ b/tools/blocktree/main.go @@ -39,7 +39,7 @@ type node struct { func main() { flag.Parse() - db, err := db.NewDB(context.Background(), *datadir, &kv.Config{}) + database, err := db.NewDB(context.Background(), *datadir, &kv.Config{}) if err != nil { panic(err) } @@ -51,7 +51,7 @@ func main() { startSlot := types.Slot(*startSlot) endSlot := types.Slot(*endSlot) filter := filters.NewFilter().SetStartSlot(startSlot).SetEndSlot(endSlot) - blks, roots, err := db.Blocks(context.Background(), filter) + blks, roots, err := database.Blocks(context.Background(), filter) if err != nil { panic(err) } @@ -63,7 +63,7 @@ func main() { r := roots[i] m[r] = &node{score: make(map[uint64]bool)} - state, err := db.State(context.Background(), r) + state, err := database.State(context.Background(), r) if err != nil { panic(err) } @@ -71,11 +71,11 @@ func main() { // If the state is not available, roll back for state == nil { slot-- - _, rts, err := db.BlockRootsBySlot(context.Background(), slot) + _, rts, err := database.BlockRootsBySlot(context.Background(), slot) if err != nil { panic(err) } - state, err = db.State(context.Background(), rts[0]) + state, err = database.State(context.Background(), rts[0]) if err != nil { panic(err) } diff --git a/tools/bootnode/bootnode.go b/tools/bootnode/bootnode.go index 6fb3ad2c4d..2d189b7026 100644 --- a/tools/bootnode/bootnode.go +++ b/tools/bootnode/bootnode.go @@ -156,11 +156,11 @@ func createListener(ipAddr string, port int, cfg discover.Config) *discover.UDPv log.Fatal(err) } - network, err := discover.ListenV5(conn, localNode, cfg) + net, err := discover.ListenV5(conn, localNode, cfg) if err != nil { log.Fatal(err) } - return network + return net } func (h *handler) httpHandler(w http.ResponseWriter, _ *http.Request) { diff --git a/tools/exploredb/main.go b/tools/exploredb/main.go index 810c3cd02c..8537b903c3 100644 --- a/tools/exploredb/main.go +++ b/tools/exploredb/main.go @@ -116,11 +116,10 @@ func main() { } func printBucketStats(dbNameWithPath string) { - ctx := context.Background() groupSize := uint64(128) doneC := make(chan bool) statsC := make(chan *bucketStat, groupSize) - go readBucketStat(ctx, dbNameWithPath, statsC) + go readBucketStat(dbNameWithPath, statsC) go printBucketStat(statsC, doneC) <-doneC } @@ -163,7 +162,7 @@ func printBucketContents(dbNameWithPath string, rowLimit uint64, bucketName stri <-doneC } -func readBucketStat(ctx context.Context, dbNameWithPath string, statsC chan<- *bucketStat) { +func readBucketStat(dbNameWithPath string, statsC chan<- *bucketStat) { // open the raw database file. If the file is busy, then exit. db, openErr := bolt.Open(dbNameWithPath, 0600, &bolt.Options{Timeout: 1 * time.Second}) if openErr != nil { diff --git a/tools/keystores/main.go b/tools/keystores/main.go index 4387352cf7..4fe4e980c6 100644 --- a/tools/keystores/main.go +++ b/tools/keystores/main.go @@ -223,14 +223,14 @@ func encrypt(cliCtx *cli.Context) error { // Reads the keystore file at the provided path and attempts // to decrypt it with the specified passwords. func readAndDecryptKeystore(fullPath, password string) error { - file, err := os.ReadFile(fullPath) // #nosec G304 + f, err := os.ReadFile(fullPath) // #nosec G304 if err != nil { return errors.Wrapf(err, "could not read file at path: %s", fullPath) } decryptor := keystorev4.New() keystoreFile := &keymanager.Keystore{} - if err := json.Unmarshal(file, keystoreFile); err != nil { + if err := json.Unmarshal(f, keystoreFile); err != nil { return errors.Wrap(err, "could not JSON unmarshal keystore file") } // We extract the validator signing private key from the keystore diff --git a/validator/accounts/accounts_import_test.go b/validator/accounts/accounts_import_test.go index 840cefff8a..ddf9d25317 100644 --- a/validator/accounts/accounts_import_test.go +++ b/validator/accounts/accounts_import_test.go @@ -141,7 +141,7 @@ func Test_importPrivateKeyAsAccount(t *testing.T) { privateKeyFile: privKeyFileName, }) walletPass := "Passwordz0320$" - wallet, err := CreateWalletWithKeymanager(cliCtx.Context, &CreateWalletConfig{ + w, err := CreateWalletWithKeymanager(cliCtx.Context, &CreateWalletConfig{ WalletCfg: &wallet.Config{ WalletDir: walletDir, KeymanagerKind: keymanager.Local, @@ -149,29 +149,27 @@ func Test_importPrivateKeyAsAccount(t *testing.T) { }, }) require.NoError(t, err) - keymanager, err := local.NewKeymanager( + km, err := local.NewKeymanager( cliCtx.Context, &local.SetupConfig{ - Wallet: wallet, + Wallet: w, ListenForChanges: false, }, ) require.NoError(t, err) - assert.NoError(t, importPrivateKeyAsAccount(cliCtx.Context, wallet, keymanager, privKeyFileName)) + assert.NoError(t, importPrivateKeyAsAccount(cliCtx.Context, w, km, privKeyFileName)) // We re-instantiate the keymanager and check we now have 1 public key. - keymanager, err = local.NewKeymanager( + km, err = local.NewKeymanager( cliCtx.Context, &local.SetupConfig{ - Wallet: wallet, + Wallet: w, ListenForChanges: false, }, ) require.NoError(t, err) - pubKeys, err := keymanager.FetchValidatingPublicKeys(cliCtx.Context) + pubKeys, err := km.FetchValidatingPublicKeys(cliCtx.Context) require.NoError(t, err) require.Equal(t, 1, len(pubKeys)) assert.DeepEqual(t, pubKeys[0], bytesutil.ToBytes48(privKey.PublicKey().Marshal())) } - -// Returns the fullPath to the newly created keystore file. diff --git a/validator/accounts/accounts_list_test.go b/validator/accounts/accounts_list_test.go index 0ed0cff577..c3ba6f81e5 100644 --- a/validator/accounts/accounts_list_test.go +++ b/validator/accounts/accounts_list_test.go @@ -51,7 +51,7 @@ func (_ *mockRemoteKeymanager) SubscribeAccountChanges(_ chan [][fieldparams.BLS } func (_ *mockRemoteKeymanager) ExtractKeystores( - ctx context.Context, publicKeys []bls.PublicKey, password string, + _ context.Context, _ []bls.PublicKey, _ string, ) ([]*keymanager.Keystore, error) { return nil, nil } diff --git a/validator/accounts/cli_options.go b/validator/accounts/cli_options.go index eb439e3718..133922939f 100644 --- a/validator/accounts/cli_options.go +++ b/validator/accounts/cli_options.go @@ -130,7 +130,7 @@ func WithPasswordFilePath(passwordFilePath string) Option { } } -// WithBackupDir specifies the directory backups are written to. +// WithBackupsDir specifies the directory backups are written to. func WithBackupsDir(backupsDir string) Option { return func(acc *AccountsCLIManager) error { acc.backupsDir = backupsDir @@ -138,7 +138,7 @@ func WithBackupsDir(backupsDir string) Option { } } -// WithBackupPassword specifies the password for backups. +// WithBackupsPassword specifies the password for backups. func WithBackupsPassword(backupsPassword string) Option { return func(acc *AccountsCLIManager) error { acc.backupsPassword = backupsPassword diff --git a/validator/accounts/iface/wallet.go b/validator/accounts/iface/wallet.go index 21fb02f937..18669b94cf 100644 --- a/validator/accounts/iface/wallet.go +++ b/validator/accounts/iface/wallet.go @@ -4,13 +4,13 @@ import ( "context" "github.com/prysmaticlabs/prysm/validator/keymanager" - remote_web3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" + remoteweb3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" ) // InitKeymanagerConfig defines configuration options for initializing a keymanager. type InitKeymanagerConfig struct { ListenForChanges bool - Web3SignerConfig *remote_web3signer.SetupConfig + Web3SignerConfig *remoteweb3signer.SetupConfig } // Wallet defines a struct which has capabilities and knowledge of how diff --git a/validator/accounts/wallet/wallet.go b/validator/accounts/wallet/wallet.go index 4e056c3a8c..0210848a18 100644 --- a/validator/accounts/wallet/wallet.go +++ b/validator/accounts/wallet/wallet.go @@ -19,7 +19,7 @@ import ( "github.com/prysmaticlabs/prysm/validator/keymanager/derived" "github.com/prysmaticlabs/prysm/validator/keymanager/local" "github.com/prysmaticlabs/prysm/validator/keymanager/remote" - remote_web3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" + remoteweb3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" "github.com/sirupsen/logrus" "github.com/urfave/cli/v2" ) @@ -313,7 +313,7 @@ func (w *Wallet) InitializeKeymanager(ctx context.Context, cfg iface.InitKeymana if !bytesutil.IsValidRoot(config.GenesisValidatorsRoot) { return nil, errors.New("web3signer requires a genesis validators root value") } - km, err = remote_web3signer.NewKeymanager(ctx, config) + km, err = remoteweb3signer.NewKeymanager(ctx, config) if err != nil { return nil, errors.Wrap(err, "could not initialize web3signer keymanager") } diff --git a/validator/accounts/wallet/wallet_test.go b/validator/accounts/wallet/wallet_test.go index f0a0e093d9..ac7d0e2bf5 100644 --- a/validator/accounts/wallet/wallet_test.go +++ b/validator/accounts/wallet/wallet_test.go @@ -13,7 +13,7 @@ import ( "github.com/prysmaticlabs/prysm/testing/require" "github.com/prysmaticlabs/prysm/validator/accounts/iface" "github.com/prysmaticlabs/prysm/validator/accounts/wallet" - remote_web3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" + remoteweb3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" "github.com/sirupsen/logrus" ) @@ -62,7 +62,7 @@ func TestWallet_InitializeKeymanager_web3Signer_HappyPath(t *testing.T) { require.NoError(t, err) config := iface.InitKeymanagerConfig{ ListenForChanges: false, - Web3SignerConfig: &remote_web3signer.SetupConfig{ + Web3SignerConfig: &remoteweb3signer.SetupConfig{ BaseEndpoint: "http://localhost:8545", GenesisValidatorsRoot: root, PublicKeysURL: "http://localhost:8545/public_keys", diff --git a/validator/accounts/wallet_create.go b/validator/accounts/wallet_create.go index 3abd848240..e9bbd59b09 100644 --- a/validator/accounts/wallet_create.go +++ b/validator/accounts/wallet_create.go @@ -18,7 +18,7 @@ import ( "github.com/prysmaticlabs/prysm/validator/keymanager/derived" "github.com/prysmaticlabs/prysm/validator/keymanager/local" "github.com/prysmaticlabs/prysm/validator/keymanager/remote" - remote_web3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" + remoteweb3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" "github.com/urfave/cli/v2" ) @@ -27,7 +27,7 @@ type CreateWalletConfig struct { SkipMnemonicConfirm bool NumAccounts int RemoteKeymanagerOpts *remote.KeymanagerOpts - Web3SignerSetupConfig *remote_web3signer.SetupConfig + Web3SignerSetupConfig *remoteweb3signer.SetupConfig WalletCfg *wallet.Config Mnemonic25thWord string } diff --git a/validator/accounts/wallet_edit_test.go b/validator/accounts/wallet_edit_test.go index d6cb5f0351..55ebe4e1e0 100644 --- a/validator/accounts/wallet_edit_test.go +++ b/validator/accounts/wallet_edit_test.go @@ -19,7 +19,7 @@ func TestEditWalletConfiguration(t *testing.T) { walletDir: walletDir, keymanagerKind: keymanager.Remote, }) - wallet, err := CreateWalletWithKeymanager(cliCtx.Context, &CreateWalletConfig{ + w, err := CreateWalletWithKeymanager(cliCtx.Context, &CreateWalletConfig{ WalletCfg: &wallet.Config{ WalletDir: walletDir, KeymanagerKind: keymanager.Remote, @@ -39,7 +39,7 @@ func TestEditWalletConfiguration(t *testing.T) { } encodedCfg, err := remote.MarshalOptionsFile(cliCtx.Context, originalCfg) assert.NoError(t, err) - assert.NoError(t, wallet.WriteKeymanagerConfigToDisk(cliCtx.Context, encodedCfg)) + assert.NoError(t, w.WriteKeymanagerConfigToDisk(cliCtx.Context, encodedCfg)) wantCfg := &remote.KeymanagerOpts{ RemoteCertificate: &remote.CertificateConfig{ @@ -68,7 +68,7 @@ func TestEditWalletConfiguration(t *testing.T) { err = EditWalletConfigurationCli(cliCtx) require.NoError(t, err) - encoded, err := wallet.ReadKeymanagerConfigFromDisk(cliCtx.Context) + encoded, err := w.ReadKeymanagerConfigFromDisk(cliCtx.Context) require.NoError(t, err) cfg, err := remote.UnmarshalOptionsFile(encoded) diff --git a/validator/client/propose_test.go b/validator/client/propose_test.go index ac72e6667b..77d22d5b81 100644 --- a/validator/client/propose_test.go +++ b/validator/client/propose_test.go @@ -258,8 +258,8 @@ func TestProposeBlock_ProposeBlockFailed(t *testing.T) { func TestProposeBlock_BlocksDoubleProposal(t *testing.T) { slot := params.BeaconConfig().SlotsPerEpoch.Mul(5).Add(2) - graffiti := [32]byte{} - copy(graffiti[:], "someothergraffiti") + blockGraffiti := [32]byte{} + copy(blockGraffiti[:], "someothergraffiti") tests := []struct { name string @@ -269,7 +269,7 @@ func TestProposeBlock_BlocksDoubleProposal(t *testing.T) { name: "phase0", blocks: func() []*ethpb.GenericBeaconBlock { block0, block1 := util.NewBeaconBlock(), util.NewBeaconBlock() - block1.Block.Body.Graffiti = graffiti[:] + block1.Block.Body.Graffiti = blockGraffiti[:] var blocks []*ethpb.GenericBeaconBlock for _, block := range []*ethpb.SignedBeaconBlock{block0, block1} { @@ -287,7 +287,7 @@ func TestProposeBlock_BlocksDoubleProposal(t *testing.T) { name: "altair", blocks: func() []*ethpb.GenericBeaconBlock { block0, block1 := util.NewBeaconBlockAltair(), util.NewBeaconBlockAltair() - block1.Block.Body.Graffiti = graffiti[:] + block1.Block.Body.Graffiti = blockGraffiti[:] var blocks []*ethpb.GenericBeaconBlock for _, block := range []*ethpb.SignedBeaconBlockAltair{block0, block1} { @@ -305,7 +305,7 @@ func TestProposeBlock_BlocksDoubleProposal(t *testing.T) { name: "bellatrix", blocks: func() []*ethpb.GenericBeaconBlock { block0, block1 := util.NewBeaconBlockBellatrix(), util.NewBeaconBlockBellatrix() - block1.Block.Body.Graffiti = graffiti[:] + block1.Block.Body.Graffiti = blockGraffiti[:] var blocks []*ethpb.GenericBeaconBlock for _, block := range []*ethpb.SignedBeaconBlockBellatrix{block0, block1} { @@ -398,9 +398,9 @@ func TestProposeBlock_BlocksDoubleProposal_After54KEpochs(t *testing.T) { secondTestBlock := util.NewBeaconBlock() secondTestBlock.Block.Slot = farFuture - graffiti := [32]byte{} - copy(graffiti[:], "someothergraffiti") - secondTestBlock.Block.Body.Graffiti = graffiti[:] + blockGraffiti := [32]byte{} + copy(blockGraffiti[:], "someothergraffiti") + secondTestBlock.Block.Body.Graffiti = blockGraffiti[:] m.validatorClient.EXPECT().GetBeaconBlock( gomock.Any(), // ctx gomock.AssignableToTypeOf(ðpb.BlockRequest{}), @@ -504,8 +504,8 @@ func TestProposeBlock_BroadcastsBlock(t *testing.T) { } func TestProposeBlock_BroadcastsBlock_WithGraffiti(t *testing.T) { - graffiti := []byte("12345678901234567890123456789012") - testProposeBlock(t, graffiti) + blockGraffiti := []byte("12345678901234567890123456789012") + testProposeBlock(t, blockGraffiti) } func testProposeBlock(t *testing.T, graffiti []byte) { diff --git a/validator/client/registration.go b/validator/client/registration.go index 671590f1bf..d247690f80 100644 --- a/validator/client/registration.go +++ b/validator/client/registration.go @@ -2,23 +2,19 @@ package client import ( "context" - "time" "github.com/pkg/errors" "github.com/prysmaticlabs/prysm/beacon-chain/core/signing" "github.com/prysmaticlabs/prysm/config/params" - types "github.com/prysmaticlabs/prysm/consensus-types/primitives" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" validatorpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/validator-client" "go.opencensus.io/trace" - "google.golang.org/protobuf/types/known/emptypb" ) // SubmitValidatorRegistration signs validator registration object and submits it to the beacon node. func SubmitValidatorRegistration( ctx context.Context, validatorClient ethpb.BeaconNodeValidatorClient, - nodeClient ethpb.NodeClient, signer signingFunc, regs []*ethpb.ValidatorRegistrationV1, ) error { @@ -28,17 +24,10 @@ func SubmitValidatorRegistration( if len(regs) == 0 { return nil } - genesisResponse, err := nodeClient.GetGenesis(ctx, &emptypb.Empty{}) - if err != nil { - return errors.Wrap(err, "gRPC call to get genesis time failed") - } - ts := time.Unix(int64(regs[0].Timestamp), 0) - secs := int64(ts.Second()) - genesisResponse.GenesisTime.Seconds - currentSlot := types.Slot(uint64(secs) / params.BeaconConfig().SecondsPerSlot) signedRegs := make([]*ethpb.SignedValidatorRegistrationV1, len(regs)) for i, reg := range regs { - sig, err := signValidatorRegistration(ctx, currentSlot, validatorClient, signer, reg) + sig, err := signValidatorRegistration(ctx, signer, reg) if err != nil { log.WithError(err).Error("failed to sign builder validator registration obj") continue @@ -59,13 +48,7 @@ func SubmitValidatorRegistration( } // Sings validator registration obj with the proposer domain and private key. -func signValidatorRegistration( - ctx context.Context, - slot types.Slot, - validatorClient ethpb.BeaconNodeValidatorClient, - signer signingFunc, - reg *ethpb.ValidatorRegistrationV1, -) ([]byte, error) { +func signValidatorRegistration(ctx context.Context, signer signingFunc, reg *ethpb.ValidatorRegistrationV1) ([]byte, error) { // Per spec, we want the fork version and genesis validator to be nil. // Which is genesis value and zero by default. diff --git a/validator/client/registration_test.go b/validator/client/registration_test.go index f7077567d8..44ed4b8977 100644 --- a/validator/client/registration_test.go +++ b/validator/client/registration_test.go @@ -11,8 +11,6 @@ import ( "github.com/prysmaticlabs/prysm/encoding/bytesutil" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/testing/require" - "google.golang.org/protobuf/types/known/emptypb" - "google.golang.org/protobuf/types/known/timestamppb" ) func TestSubmitValidatorRegistration(t *testing.T) { @@ -20,7 +18,7 @@ func TestSubmitValidatorRegistration(t *testing.T) { defer finish() ctx := context.Background() - require.NoError(t, nil, SubmitValidatorRegistration(ctx, m.validatorClient, m.nodeClient, m.signfunc, []*ethpb.ValidatorRegistrationV1{})) + require.NoError(t, nil, SubmitValidatorRegistration(ctx, m.validatorClient, m.signfunc, []*ethpb.ValidatorRegistrationV1{})) reg := ðpb.ValidatorRegistrationV1{ FeeRecipient: bytesutil.PadTo([]byte("fee"), 20), @@ -30,11 +28,6 @@ func TestSubmitValidatorRegistration(t *testing.T) { } regs := []*ethpb.ValidatorRegistrationV1{reg} - ti := ×tamppb.Timestamp{} - m.nodeClient.EXPECT(). - GetGenesis(gomock.Any(), &emptypb.Empty{}). - Return(ðpb.Genesis{GenesisTime: ti}, nil) - m.validatorClient.EXPECT(). SubmitValidatorRegistration(gomock.Any(), ðpb.SignedValidatorRegistrationsV1{ Messages: []*ethpb.SignedValidatorRegistrationV1{ @@ -43,7 +36,7 @@ func TestSubmitValidatorRegistration(t *testing.T) { }, }). Return(nil, nil) - require.NoError(t, nil, SubmitValidatorRegistration(ctx, m.validatorClient, m.nodeClient, m.signfunc, regs)) + require.NoError(t, nil, SubmitValidatorRegistration(ctx, m.validatorClient, m.signfunc, regs)) } func TestSubmitValidatorRegistration_CantSign(t *testing.T) { @@ -59,11 +52,6 @@ func TestSubmitValidatorRegistration_CantSign(t *testing.T) { } regs := []*ethpb.ValidatorRegistrationV1{reg} - genesisTime := ×tamppb.Timestamp{} - m.nodeClient.EXPECT(). - GetGenesis(gomock.Any(), &emptypb.Empty{}). - Return(ðpb.Genesis{GenesisTime: genesisTime}, nil) - m.validatorClient.EXPECT(). SubmitValidatorRegistration(gomock.Any(), ðpb.SignedValidatorRegistrationsV1{ Messages: []*ethpb.SignedValidatorRegistrationV1{ @@ -72,7 +60,7 @@ func TestSubmitValidatorRegistration_CantSign(t *testing.T) { }, }). Return(nil, errors.New("could not sign")) - require.ErrorContains(t, "could not sign", SubmitValidatorRegistration(ctx, m.validatorClient, m.nodeClient, m.signfunc, regs)) + require.ErrorContains(t, "could not sign", SubmitValidatorRegistration(ctx, m.validatorClient, m.signfunc, regs)) } func Test_signValidatorRegistration(t *testing.T) { @@ -86,10 +74,7 @@ func Test_signValidatorRegistration(t *testing.T) { Timestamp: uint64(time.Now().Unix()), Pubkey: validatorKey.PublicKey().Marshal(), } - _, err := signValidatorRegistration( - ctx, - 1, - m.validatorClient, m.signfunc, reg) + _, err := signValidatorRegistration(ctx, m.signfunc, reg) require.NoError(t, err) } diff --git a/validator/client/service.go b/validator/client/service.go index 8301aefbe3..4933cf8a9a 100644 --- a/validator/client/service.go +++ b/validator/client/service.go @@ -7,16 +7,16 @@ import ( "github.com/dgraph-io/ristretto" middleware "github.com/grpc-ecosystem/go-grpc-middleware" - grpc_retry "github.com/grpc-ecosystem/go-grpc-middleware/retry" - grpc_opentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing" - grpc_prometheus "github.com/grpc-ecosystem/go-grpc-prometheus" + grpcretry "github.com/grpc-ecosystem/go-grpc-middleware/retry" + grpcopentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing" + grpcprometheus "github.com/grpc-ecosystem/go-grpc-prometheus" "github.com/pkg/errors" grpcutil "github.com/prysmaticlabs/prysm/api/grpc" "github.com/prysmaticlabs/prysm/async/event" lruwrpr "github.com/prysmaticlabs/prysm/cache/lru" fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams" "github.com/prysmaticlabs/prysm/config/params" - validator_service_config "github.com/prysmaticlabs/prysm/config/validator/service" + validatorserviceconfig "github.com/prysmaticlabs/prysm/config/validator/service" "github.com/prysmaticlabs/prysm/consensus-types/interfaces" types "github.com/prysmaticlabs/prysm/consensus-types/primitives" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" @@ -26,7 +26,7 @@ import ( "github.com/prysmaticlabs/prysm/validator/graffiti" "github.com/prysmaticlabs/prysm/validator/keymanager" "github.com/prysmaticlabs/prysm/validator/keymanager/local" - remote_web3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" + remoteweb3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" "go.opencensus.io/plugin/ocgrpc" "google.golang.org/grpc" "google.golang.org/grpc/credentials" @@ -69,8 +69,8 @@ type ValidatorService struct { db db.Database grpcHeaders []string graffiti []byte - Web3SignerConfig *remote_web3signer.SetupConfig - ProposerSettings *validator_service_config.ProposerSettings + Web3SignerConfig *remoteweb3signer.SetupConfig + ProposerSettings *validatorserviceconfig.ProposerSettings } // Config for the validator service. @@ -93,8 +93,8 @@ type Config struct { GrpcHeadersFlag string GraffitiFlag string Endpoint string - Web3SignerConfig *remote_web3signer.SetupConfig - ProposerSettings *validator_service_config.ProposerSettings + Web3SignerConfig *remoteweb3signer.SetupConfig + ProposerSettings *validatorserviceconfig.ProposerSettings } // NewValidatorService creates a new validator service for the service @@ -281,21 +281,21 @@ func ConstructDialOptions( transportSecurity, grpc.WithDefaultCallOptions( grpc.MaxCallRecvMsgSize(maxCallRecvMsgSize), - grpc_retry.WithMax(grpcRetries), - grpc_retry.WithBackoff(grpc_retry.BackoffLinear(grpcRetryDelay)), + grpcretry.WithMax(grpcRetries), + grpcretry.WithBackoff(grpcretry.BackoffLinear(grpcRetryDelay)), ), grpc.WithStatsHandler(&ocgrpc.ClientHandler{}), grpc.WithUnaryInterceptor(middleware.ChainUnaryClient( - grpc_opentracing.UnaryClientInterceptor(), - grpc_prometheus.UnaryClientInterceptor, - grpc_retry.UnaryClientInterceptor(), + grpcopentracing.UnaryClientInterceptor(), + grpcprometheus.UnaryClientInterceptor, + grpcretry.UnaryClientInterceptor(), grpcutil.LogRequests, )), grpc.WithChainStreamInterceptor( grpcutil.LogStream, - grpc_opentracing.StreamClientInterceptor(), - grpc_prometheus.StreamClientInterceptor, - grpc_retry.StreamClientInterceptor(), + grpcopentracing.StreamClientInterceptor(), + grpcprometheus.StreamClientInterceptor, + grpcretry.StreamClientInterceptor(), ), grpc.WithResolvers(&multipleEndpointsGrpcResolverBuilder{}), } diff --git a/validator/client/validator.go b/validator/client/validator.go index d7e703d2fa..544daee060 100644 --- a/validator/client/validator.go +++ b/validator/client/validator.go @@ -25,7 +25,7 @@ import ( "github.com/prysmaticlabs/prysm/config/features" fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams" "github.com/prysmaticlabs/prysm/config/params" - validator_service_config "github.com/prysmaticlabs/prysm/config/validator/service" + validatorserviceconfig "github.com/prysmaticlabs/prysm/config/validator/service" "github.com/prysmaticlabs/prysm/consensus-types/interfaces" types "github.com/prysmaticlabs/prysm/consensus-types/primitives" "github.com/prysmaticlabs/prysm/consensus-types/wrapper" @@ -41,7 +41,7 @@ import ( "github.com/prysmaticlabs/prysm/validator/graffiti" "github.com/prysmaticlabs/prysm/validator/keymanager" "github.com/prysmaticlabs/prysm/validator/keymanager/local" - remote_web3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" + remoteweb3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" "github.com/sirupsen/logrus" "go.opencensus.io/trace" "google.golang.org/protobuf/proto" @@ -95,8 +95,8 @@ type validator struct { validatorClient ethpb.BeaconNodeValidatorClient graffiti []byte voteStats voteStats - Web3SignerConfig *remote_web3signer.SetupConfig - ProposerSettings *validator_service_config.ProposerSettings + Web3SignerConfig *remoteweb3signer.SetupConfig + ProposerSettings *validatorserviceconfig.ProposerSettings walletIntializedChannel chan *wallet.Wallet } @@ -981,7 +981,7 @@ func (v *validator) PushProposerSettings(ctx context.Context, km keymanager.IKey } log.Infoln("Successfully prepared beacon proposer with fee recipient to validator index mapping.") - if err := SubmitValidatorRegistration(ctx, v.validatorClient, v.node, km.Sign, registerValidatorRequests); err != nil { + if err := SubmitValidatorRegistration(ctx, v.validatorClient, km.Sign, registerValidatorRequests); err != nil { return err } log.Infoln("Successfully submitted builder validator registration settings for custom builders.") diff --git a/validator/client/validator_test.go b/validator/client/validator_test.go index 5b26a30ac5..478a34666b 100644 --- a/validator/client/validator_test.go +++ b/validator/client/validator_test.go @@ -19,7 +19,7 @@ import ( "github.com/prysmaticlabs/prysm/config/features" fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams" "github.com/prysmaticlabs/prysm/config/params" - validator_service_config "github.com/prysmaticlabs/prysm/config/validator/service" + validatorserviceconfig "github.com/prysmaticlabs/prysm/config/validator/service" types "github.com/prysmaticlabs/prysm/consensus-types/primitives" "github.com/prysmaticlabs/prysm/crypto/bls" "github.com/prysmaticlabs/prysm/encoding/bytesutil" @@ -35,12 +35,11 @@ import ( dbTest "github.com/prysmaticlabs/prysm/validator/db/testing" "github.com/prysmaticlabs/prysm/validator/keymanager" "github.com/prysmaticlabs/prysm/validator/keymanager/local" - remote_web3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" + remoteweb3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" "github.com/sirupsen/logrus" logTest "github.com/sirupsen/logrus/hooks/test" "google.golang.org/grpc" "google.golang.org/protobuf/types/known/emptypb" - "google.golang.org/protobuf/types/known/timestamppb" ) func init() { @@ -109,7 +108,7 @@ func (m *mockKeymanager) SimulateAccountChanges(newKeys [][fieldparams.BLSPubkey } func (*mockKeymanager) ExtractKeystores( - ctx context.Context, publicKeys []bls.PublicKey, password string, + _ context.Context, _ []bls.PublicKey, _ string, ) ([]*keymanager.Keystore, error) { return nil, errors.New("extracting keys not supported on mock keymanager") } @@ -375,9 +374,9 @@ func TestWaitMultipleActivation_LogsActivationEpochOK(t *testing.T) { node: nodeClient, genesisTime: 1, pubkeyToValidatorIndex: map[[fieldparams.BLSPubkeyLength]byte]types.ValidatorIndex{pubKey: 1}, - ProposerSettings: &validator_service_config.ProposerSettings{ + ProposerSettings: &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"), }, }, @@ -397,12 +396,6 @@ func TestWaitMultipleActivation_LogsActivationEpochOK(t *testing.T) { nil, ) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) - client.EXPECT().SubmitValidatorRegistration( gomock.Any(), gomock.Any(), @@ -438,9 +431,9 @@ func TestWaitActivation_NotAllValidatorsActivatedOK(t *testing.T) { keyManager: km, genesisTime: 1, pubkeyToValidatorIndex: map[[fieldparams.BLSPubkeyLength]byte]types.ValidatorIndex{pubKey: 1}, - ProposerSettings: &validator_service_config.ProposerSettings{ + ProposerSettings: &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"), }, }, @@ -460,11 +453,6 @@ func TestWaitActivation_NotAllValidatorsActivatedOK(t *testing.T) { resp, nil, ) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), @@ -1428,7 +1416,7 @@ func TestValidator_WaitForKeymanagerInitialization_web3Signer(t *testing.T) { db: db, useWeb: false, wallet: w, - Web3SignerConfig: &remote_web3signer.SetupConfig{ + Web3SignerConfig: &remoteweb3signer.SetupConfig{ BaseEndpoint: "http://localhost:8545", ProvidedPublicKeys: keys, }, @@ -1533,7 +1521,7 @@ func TestValidator_PushProposerSettings(t *testing.T) { } err := v.WaitForKeymanagerInitialization(ctx) require.NoError(t, err) - config := make(map[[fieldparams.BLSPubkeyLength]byte]*validator_service_config.ProposerOption) + config := make(map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption) km, err := v.Keymanager() require.NoError(t, err) keys, err := km.FetchValidatingPublicKeys(ctx) @@ -1556,22 +1544,17 @@ func TestValidator_PushProposerSettings(t *testing.T) { {FeeRecipient: common.HexToAddress(defaultFeeHex).Bytes(), ValidatorIndex: 2}, }, }).Return(nil, nil) - config[keys[0]] = &validator_service_config.ProposerOption{ + config[keys[0]] = &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x055Fb65722E7b2455043BFEBf6177F1D2e9738D9"), GasLimit: uint64(40000000), } - v.ProposerSettings = &validator_service_config.ProposerSettings{ + v.ProposerSettings = &validatorserviceconfig.ProposerSettings{ ProposeConfig: config, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress(defaultFeeHex), GasLimit: uint64(35000000), }, } - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Times(2).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), gomock.Any(), @@ -1618,9 +1601,9 @@ func TestValidator_PushProposerSettings(t *testing.T) { require.NoError(t, err) keys, err := km.FetchValidatingPublicKeys(ctx) require.NoError(t, err) - v.ProposerSettings = &validator_service_config.ProposerSettings{ + v.ProposerSettings = &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress(defaultFeeHex), GasLimit: params.BeaconConfig().DefaultBuilderGasLimit, }, @@ -1631,11 +1614,6 @@ func TestValidator_PushProposerSettings(t *testing.T) { ).Return(ðpb.ValidatorIndexResponse{ Index: 1, }, nil) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), @@ -1694,9 +1672,9 @@ func TestValidator_PushProposerSettings(t *testing.T) { } err := v.WaitForKeymanagerInitialization(ctx) require.NoError(t, err) - v.ProposerSettings = &validator_service_config.ProposerSettings{ + v.ProposerSettings = &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress(defaultFeeHex), }, } @@ -1710,11 +1688,6 @@ func TestValidator_PushProposerSettings(t *testing.T) { ).Return(ðpb.ValidatorIndexResponse{ Index: 1, }, nil) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), @@ -1754,7 +1727,7 @@ func TestValidator_PushProposerSettings(t *testing.T) { } err := v.WaitForKeymanagerInitialization(ctx) require.NoError(t, err) - config := make(map[[fieldparams.BLSPubkeyLength]byte]*validator_service_config.ProposerOption) + config := make(map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption) km, err := v.Keymanager() require.NoError(t, err) keys, err := km.FetchValidatingPublicKeys(ctx) @@ -1770,12 +1743,12 @@ func TestValidator_PushProposerSettings(t *testing.T) { {FeeRecipient: common.HexToAddress("0x0").Bytes(), ValidatorIndex: 1}, }, }).Return(nil, nil) - config[keys[0]] = &validator_service_config.ProposerOption{ + config[keys[0]] = &validatorserviceconfig.ProposerOption{ FeeRecipient: common.Address{}, } - v.ProposerSettings = &validator_service_config.ProposerSettings{ + v.ProposerSettings = &validatorserviceconfig.ProposerSettings{ ProposeConfig: config, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress(defaultFeeHex), }, } @@ -1798,7 +1771,7 @@ func TestValidator_PushProposerSettings(t *testing.T) { } err := v.WaitForKeymanagerInitialization(ctx) require.NoError(t, err) - config := make(map[[fieldparams.BLSPubkeyLength]byte]*validator_service_config.ProposerOption) + config := make(map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption) km, err := v.Keymanager() require.NoError(t, err) keys, err := km.FetchValidatingPublicKeys(ctx) @@ -1807,12 +1780,12 @@ func TestValidator_PushProposerSettings(t *testing.T) { gomock.Any(), // ctx ðpb.ValidatorIndexRequest{PublicKey: keys[0][:]}, ).Return(nil, errors.New("could not find validator index for public key")) - config[keys[0]] = &validator_service_config.ProposerOption{ + config[keys[0]] = &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9"), } - v.ProposerSettings = &validator_service_config.ProposerSettings{ + v.ProposerSettings = &validatorserviceconfig.ProposerSettings{ ProposeConfig: config, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress(defaultFeeHex), }, } @@ -1855,7 +1828,7 @@ func TestValidator_PushProposerSettings(t *testing.T) { } err := v.WaitForKeymanagerInitialization(ctx) require.NoError(t, err) - config := make(map[[fieldparams.BLSPubkeyLength]byte]*validator_service_config.ProposerOption) + config := make(map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption) km, err := v.Keymanager() require.NoError(t, err) keys, err := km.FetchValidatingPublicKeys(ctx) @@ -1871,20 +1844,15 @@ func TestValidator_PushProposerSettings(t *testing.T) { {FeeRecipient: common.HexToAddress("0x0").Bytes(), ValidatorIndex: 1}, }, }).Return(nil, nil) - config[keys[0]] = &validator_service_config.ProposerOption{ + config[keys[0]] = &validatorserviceconfig.ProposerOption{ FeeRecipient: common.Address{}, } - v.ProposerSettings = &validator_service_config.ProposerSettings{ + v.ProposerSettings = &validatorserviceconfig.ProposerSettings{ ProposeConfig: config, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress(defaultFeeHex), }, } - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), diff --git a/validator/client/wait_for_activation_test.go b/validator/client/wait_for_activation_test.go index fc2acfecef..41a36e6edc 100644 --- a/validator/client/wait_for_activation_test.go +++ b/validator/client/wait_for_activation_test.go @@ -11,7 +11,7 @@ import ( "github.com/golang/protobuf/ptypes/empty" "github.com/pkg/errors" fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams" - validator_service_config "github.com/prysmaticlabs/prysm/config/validator/service" + validatorserviceconfig "github.com/prysmaticlabs/prysm/config/validator/service" types "github.com/prysmaticlabs/prysm/consensus-types/primitives" "github.com/prysmaticlabs/prysm/crypto/bls" "github.com/prysmaticlabs/prysm/encoding/bytesutil" @@ -28,8 +28,6 @@ import ( logTest "github.com/sirupsen/logrus/hooks/test" "github.com/tyler-smith/go-bip39" util "github.com/wealdtech/go-eth2-util" - "google.golang.org/protobuf/types/known/emptypb" - "google.golang.org/protobuf/types/known/timestamppb" ) func TestWaitActivation_ContextCanceled(t *testing.T) { @@ -85,9 +83,9 @@ func TestWaitActivation_StreamSetupFails_AttemptsToReconnect(t *testing.T) { node: nodeClient, keyManager: km, pubkeyToValidatorIndex: make(map[[fieldparams.BLSPubkeyLength]byte]types.ValidatorIndex), - ProposerSettings: &validator_service_config.ProposerSettings{ + ProposerSettings: &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9"), }, }, @@ -108,11 +106,6 @@ func TestWaitActivation_StreamSetupFails_AttemptsToReconnect(t *testing.T) { resp := generateMockStatusResponse([][]byte{pubKey[:]}) resp.Statuses[0].Status.Status = ethpb.ValidatorStatus_ACTIVE clientStream.EXPECT().Recv().Return(resp, nil) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), @@ -140,9 +133,9 @@ func TestWaitForActivation_ReceiveErrorFromStream_AttemptsReconnection(t *testin node: nodeClient, keyManager: km, pubkeyToValidatorIndex: make(map[[fieldparams.BLSPubkeyLength]byte]types.ValidatorIndex), - ProposerSettings: &validator_service_config.ProposerSettings{ + ProposerSettings: &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9"), }, }, @@ -167,11 +160,6 @@ func TestWaitForActivation_ReceiveErrorFromStream_AttemptsReconnection(t *testin nil, errors.New("fails"), ).Return(resp, nil) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), @@ -201,9 +189,9 @@ func TestWaitActivation_LogsActivationEpochOK(t *testing.T) { keyManager: km, genesisTime: 1, pubkeyToValidatorIndex: make(map[[fieldparams.BLSPubkeyLength]byte]types.ValidatorIndex), - ProposerSettings: &validator_service_config.ProposerSettings{ + ProposerSettings: &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9"), }, }, @@ -222,11 +210,6 @@ func TestWaitActivation_LogsActivationEpochOK(t *testing.T) { resp, nil, ) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), @@ -261,9 +244,9 @@ func TestWaitForActivation_Exiting(t *testing.T) { keyManager: km, genesisTime: 1, pubkeyToValidatorIndex: make(map[[fieldparams.BLSPubkeyLength]byte]types.ValidatorIndex), - ProposerSettings: &validator_service_config.ProposerSettings{ + ProposerSettings: &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9"), }, }, @@ -282,11 +265,6 @@ func TestWaitForActivation_Exiting(t *testing.T) { resp, nil, ) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), @@ -328,9 +306,9 @@ func TestWaitForActivation_RefetchKeys(t *testing.T) { keyManager: km, genesisTime: 1, pubkeyToValidatorIndex: make(map[[fieldparams.BLSPubkeyLength]byte]types.ValidatorIndex), - ProposerSettings: &validator_service_config.ProposerSettings{ + ProposerSettings: &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9"), }, }, @@ -348,11 +326,6 @@ func TestWaitForActivation_RefetchKeys(t *testing.T) { clientStream.EXPECT().Recv().Return( resp, nil) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), @@ -396,9 +369,9 @@ func TestWaitForActivation_AccountsChanged(t *testing.T) { keyManager: km, genesisTime: 1, pubkeyToValidatorIndex: make(map[[fieldparams.BLSPubkeyLength]byte]types.ValidatorIndex), - ProposerSettings: &validator_service_config.ProposerSettings{ + ProposerSettings: &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9"), }, }, @@ -438,11 +411,6 @@ func TestWaitForActivation_AccountsChanged(t *testing.T) { activeResp, nil, ) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Times(1).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), @@ -495,9 +463,9 @@ func TestWaitForActivation_AccountsChanged(t *testing.T) { keyManager: km, genesisTime: 1, pubkeyToValidatorIndex: make(map[[fieldparams.BLSPubkeyLength]byte]types.ValidatorIndex), - ProposerSettings: &validator_service_config.ProposerSettings{ + ProposerSettings: &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9"), }, }, @@ -538,11 +506,6 @@ func TestWaitForActivation_AccountsChanged(t *testing.T) { activeResp, nil, ) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Times(1).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), @@ -600,9 +563,9 @@ func TestWaitForActivation_RemoteKeymanager(t *testing.T) { keyManager: &km, ticker: ticker, pubkeyToValidatorIndex: make(map[[fieldparams.BLSPubkeyLength]byte]types.ValidatorIndex), - ProposerSettings: &validator_service_config.ProposerSettings{ + ProposerSettings: &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9"), }, }, @@ -625,15 +588,10 @@ func TestWaitForActivation_RemoteKeymanager(t *testing.T) { PublicKeys: [][]byte{inactiveKey[:], activeKey[:]}, }, ).Return(resp, nil /* err */) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Times(1).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) client.EXPECT().SubmitValidatorRegistration( gomock.Any(), gomock.Any(), - ).Times(2).Return(&empty.Empty{}, nil) + ).Times(1).Return(&empty.Empty{}, nil) client.EXPECT().PrepareBeaconProposer(gomock.Any(), ðpb.PrepareBeaconProposerRequest{ Recipients: []*ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer{ {FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9").Bytes(), ValidatorIndex: 2}, @@ -683,9 +641,9 @@ func TestWaitForActivation_RemoteKeymanager(t *testing.T) { keyManager: &remoteKm, ticker: ticker, pubkeyToValidatorIndex: make(map[[fieldparams.BLSPubkeyLength]byte]types.ValidatorIndex), - ProposerSettings: &validator_service_config.ProposerSettings{ + ProposerSettings: &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9"), }, }, @@ -719,12 +677,11 @@ func TestWaitForActivation_RemoteKeymanager(t *testing.T) { PublicKeys: [][]byte{inactiveKey[:], activeKey[:]}, }, ).Return(resp2, nil /* err */) - nodeClient.EXPECT().GetGenesis( - gomock.Any(), - &emptypb.Empty{}, - ).Times(1).Return( - ðpb.Genesis{GenesisTime: timestamppb.Now()}, nil) + client.EXPECT().SubmitValidatorRegistration( + gomock.Any(), + gomock.Any(), + ).Times(1).Return(&empty.Empty{}, nil) client.EXPECT().PrepareBeaconProposer(gomock.Any(), ðpb.PrepareBeaconProposerRequest{ Recipients: []*ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer{ {FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9").Bytes(), ValidatorIndex: 2}, diff --git a/validator/db/kv/deprecated_attester_protection.go b/validator/db/kv/deprecated_attester_protection.go index e19a59381e..918230c4ef 100644 --- a/validator/db/kv/deprecated_attester_protection.go +++ b/validator/db/kv/deprecated_attester_protection.go @@ -1,7 +1,6 @@ package kv import ( - "context" "fmt" fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams" @@ -64,10 +63,9 @@ func newDeprecatedAttestingHistory(target types.Epoch) deprecatedEncodedAttestin arraySize := latestEpochWrittenSize + historyDataSize en := make(deprecatedEncodedAttestingHistory, arraySize) enc := en - ctx := context.Background() var err error for i := types.Epoch(0); i <= target%params.BeaconConfig().WeakSubjectivityPeriod; i++ { - enc, err = enc.setTargetData(ctx, i, emptyHistoryData()) + enc, err = enc.setTargetData(i, emptyHistoryData()) if err != nil { log.WithError(err).Error("Failed to set empty target data") } @@ -75,17 +73,14 @@ func newDeprecatedAttestingHistory(target types.Epoch) deprecatedEncodedAttestin return enc } -func (dh deprecatedEncodedAttestingHistory) getLatestEpochWritten(ctx context.Context) (types.Epoch, error) { +func (dh deprecatedEncodedAttestingHistory) getLatestEpochWritten() (types.Epoch, error) { if err := dh.assertSize(); err != nil { return 0, err } return types.Epoch(bytesutil.FromBytes8(dh[:latestEpochWrittenSize])), nil } -func (dh deprecatedEncodedAttestingHistory) setLatestEpochWritten( - ctx context.Context, - latestEpochWritten types.Epoch, -) (deprecatedEncodedAttestingHistory, error) { +func (dh deprecatedEncodedAttestingHistory) setLatestEpochWritten(latestEpochWritten types.Epoch) (deprecatedEncodedAttestingHistory, error) { if err := dh.assertSize(); err != nil { return nil, err } @@ -93,7 +88,7 @@ func (dh deprecatedEncodedAttestingHistory) setLatestEpochWritten( return dh, nil } -func (dh deprecatedEncodedAttestingHistory) getTargetData(ctx context.Context, target types.Epoch) (*deprecatedHistoryData, error) { +func (dh deprecatedEncodedAttestingHistory) getTargetData(target types.Epoch) (*deprecatedHistoryData, error) { if err := dh.assertSize(); err != nil { return nil, err } @@ -111,11 +106,7 @@ func (dh deprecatedEncodedAttestingHistory) getTargetData(ctx context.Context, t return history, nil } -func (dh deprecatedEncodedAttestingHistory) setTargetData( - ctx context.Context, - target types.Epoch, - historyData *deprecatedHistoryData, -) (deprecatedEncodedAttestingHistory, error) { +func (dh deprecatedEncodedAttestingHistory) setTargetData(target types.Epoch, historyData *deprecatedHistoryData) (deprecatedEncodedAttestingHistory, error) { if err := dh.assertSize(); err != nil { return nil, err } diff --git a/validator/db/kv/deprecated_attester_protection_test.go b/validator/db/kv/deprecated_attester_protection_test.go index 032078fe0b..086b35ecf0 100644 --- a/validator/db/kv/deprecated_attester_protection_test.go +++ b/validator/db/kv/deprecated_attester_protection_test.go @@ -1,7 +1,6 @@ package kv import ( - "context" "testing" "github.com/prysmaticlabs/prysm/config/params" @@ -34,37 +33,33 @@ func TestSizeChecks(t *testing.T) { } func TestGetLatestEpochWritten(t *testing.T) { - ctx := context.Background() ha := newDeprecatedAttestingHistory(0) ha[0] = 28 - lew, err := ha.getLatestEpochWritten(ctx) + lew, err := ha.getLatestEpochWritten() require.NoError(t, err) assert.Equal(t, types.Epoch(28), lew) } func TestSetLatestEpochWritten(t *testing.T) { - ctx := context.Background() ha := newDeprecatedAttestingHistory(0) - lew, err := ha.setLatestEpochWritten(ctx, 2828282828) + lew, err := ha.setLatestEpochWritten(2828282828) require.NoError(t, err) bytes := lew[:latestEpochWrittenSize] assert.Equal(t, uint64(2828282828), bytesutil.FromBytes8(bytes)) } func TestGetTargetData(t *testing.T) { - ctx := context.Background() ha := newDeprecatedAttestingHistory(0) - td, err := ha.getTargetData(ctx, 0) + td, err := ha.getTargetData(0) require.NoError(t, err) assert.DeepEqual(t, emptyHistoryData(), td) - td, err = ha.getTargetData(ctx, 1) + td, err = ha.getTargetData(1) require.NoError(t, err) var nilHist *deprecatedHistoryData require.Equal(t, nilHist, td) } func TestSetTargetData(t *testing.T) { - ctx := context.Background() type testStruct struct { name string enc deprecatedEncodedAttestingHistory @@ -105,15 +100,13 @@ func TestSetTargetData(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - enc, err := tt.enc.setTargetData(ctx, - tt.target, - &deprecatedHistoryData{ - Source: tt.source, - SigningRoot: tt.signingRoot, - }) + enc, err := tt.enc.setTargetData(tt.target, &deprecatedHistoryData{ + Source: tt.source, + SigningRoot: tt.signingRoot, + }) if tt.error == "" { require.NoError(t, err) - td, err := enc.getTargetData(ctx, tt.target) + td, err := enc.getTargetData(tt.target) require.NoError(t, err) require.DeepEqual(t, bytesutil.PadTo(tt.signingRoot, 32), td.SigningRoot) require.Equal(t, tt.source, td.Source) diff --git a/validator/db/kv/genesis.go b/validator/db/kv/genesis.go index b483ad73c5..daf7784cd0 100644 --- a/validator/db/kv/genesis.go +++ b/validator/db/kv/genesis.go @@ -8,7 +8,7 @@ import ( ) // SaveGenesisValidatorsRoot saves the genesis validators root to db. -func (s *Store) SaveGenesisValidatorsRoot(ctx context.Context, genValRoot []byte) error { +func (s *Store) SaveGenesisValidatorsRoot(_ context.Context, genValRoot []byte) error { err := s.db.Update(func(tx *bolt.Tx) error { bkt := tx.Bucket(genesisInfoBucket) enc := bkt.Get(genesisValidatorsRootKey) @@ -21,7 +21,7 @@ func (s *Store) SaveGenesisValidatorsRoot(ctx context.Context, genValRoot []byte } // GenesisValidatorsRoot retrieves the genesis validators root from db. -func (s *Store) GenesisValidatorsRoot(ctx context.Context) ([]byte, error) { +func (s *Store) GenesisValidatorsRoot(_ context.Context) ([]byte, error) { var genValRoot []byte err := s.db.View(func(tx *bolt.Tx) error { bkt := tx.Bucket(genesisInfoBucket) diff --git a/validator/db/kv/graffiti.go b/validator/db/kv/graffiti.go index 0c857a0695..a899fbad55 100644 --- a/validator/db/kv/graffiti.go +++ b/validator/db/kv/graffiti.go @@ -9,7 +9,7 @@ import ( ) // SaveGraffitiOrderedIndex writes the current graffiti index to the db -func (s *Store) SaveGraffitiOrderedIndex(ctx context.Context, index uint64) error { +func (s *Store) SaveGraffitiOrderedIndex(_ context.Context, index uint64) error { return s.db.Update(func(tx *bolt.Tx) error { bkt := tx.Bucket(graffitiBucket) indexBytes := bytesutil.Uint64ToBytesBigEndian(index) @@ -18,7 +18,7 @@ func (s *Store) SaveGraffitiOrderedIndex(ctx context.Context, index uint64) erro } // GraffitiOrderedIndex fetches the ordered index, resetting if the file hash changed -func (s *Store) GraffitiOrderedIndex(ctx context.Context, fileHash [32]byte) (uint64, error) { +func (s *Store) GraffitiOrderedIndex(_ context.Context, fileHash [32]byte) (uint64, error) { orderedIndex := uint64(0) err := s.db.Update(func(tx *bolt.Tx) error { bkt := tx.Bucket(graffitiBucket) diff --git a/validator/db/kv/migration_optimal_attester_protection.go b/validator/db/kv/migration_optimal_attester_protection.go index e889c3e381..ff9003fe53 100644 --- a/validator/db/kv/migration_optimal_attester_protection.go +++ b/validator/db/kv/migration_optimal_attester_protection.go @@ -18,7 +18,7 @@ var migrationOptimalAttesterProtectionKey = []byte("optimal_attester_protection_ // stored attesting history as large, 2Mb arrays per validator, we need to perform // this migration differently than the rest, ensuring we perform each expensive bolt // update in its own transaction to prevent having everything on the heap. -func (s *Store) migrateOptimalAttesterProtectionUp(ctx context.Context) error { +func (s *Store) migrateOptimalAttesterProtectionUp(_ context.Context) error { publicKeyBytes := make([][]byte, 0) attestingHistoryBytes := make([][]byte, 0) numKeys := 0 @@ -76,14 +76,14 @@ func (s *Store) migrateOptimalAttesterProtectionUp(ctx context.Context) error { // Extract every single source, target, signing root // from the attesting history then insert them into the // respective buckets under the new db schema. - latestEpochWritten, err := attestingHistory.getLatestEpochWritten(ctx) + latestEpochWritten, err := attestingHistory.getLatestEpochWritten() if err != nil { return err } // For every epoch since genesis up to the highest epoch written, we then // extract historical data and insert it into the new schema. for targetEpoch := types.Epoch(0); targetEpoch <= latestEpochWritten; targetEpoch++ { - historicalAtt, err := attestingHistory.getTargetData(ctx, targetEpoch) + historicalAtt, err := attestingHistory.getTargetData(targetEpoch) if err != nil { return err } @@ -113,7 +113,7 @@ func (s *Store) migrateOptimalAttesterProtectionUp(ctx context.Context) error { } // Migrate attester protection from the more optimal format to the old format in the DB. -func (s *Store) migrateOptimalAttesterProtectionDown(ctx context.Context) error { +func (s *Store) migrateOptimalAttesterProtectionDown(_ context.Context) error { // First we extract the public keys we are migrating down for. pubKeys, err := s.extractPubKeysForMigratingDown() if err != nil { @@ -183,7 +183,7 @@ func (s *Store) migrateOptimalAttesterProtectionDown(ctx context.Context) error if sr, ok := signingRootsByTarget[target]; ok { signingRoot = sr } - newHist, err := history.setTargetData(ctx, target, &deprecatedHistoryData{ + newHist, err := history.setTargetData(target, &deprecatedHistoryData{ Source: source, SigningRoot: signingRoot, }) @@ -196,7 +196,7 @@ func (s *Store) migrateOptimalAttesterProtectionDown(ctx context.Context) error } } } - newHist, err := history.setLatestEpochWritten(ctx, maxTargetWritten) + newHist, err := history.setLatestEpochWritten(maxTargetWritten) if err != nil { return err } diff --git a/validator/db/kv/migration_optimal_attester_protection_test.go b/validator/db/kv/migration_optimal_attester_protection_test.go index ebb2ee9373..3042fc1b47 100644 --- a/validator/db/kv/migration_optimal_attester_protection_test.go +++ b/validator/db/kv/migration_optimal_attester_protection_test.go @@ -38,7 +38,6 @@ func Test_migrateOptimalAttesterProtectionUp(t *testing.T) { { name: "populates optimized schema buckets", setup: func(t *testing.T, validatorDB *Store) { - ctx := context.Background() pubKey := [fieldparams.BLSPubkeyLength]byte{1} history := newDeprecatedAttestingHistory(0) // Attest all epochs from genesis to 50. @@ -46,14 +45,14 @@ func Test_migrateOptimalAttesterProtectionUp(t *testing.T) { for i := types.Epoch(1); i <= numEpochs; i++ { var sr [32]byte copy(sr[:], fmt.Sprintf("%d", i)) - newHist, err := history.setTargetData(ctx, i, &deprecatedHistoryData{ + newHist, err := history.setTargetData(i, &deprecatedHistoryData{ Source: i - 1, SigningRoot: sr[:], }) require.NoError(t, err) history = newHist } - newHist, err := history.setLatestEpochWritten(ctx, numEpochs) + newHist, err := history.setLatestEpochWritten(numEpochs) require.NoError(t, err) err = validatorDB.update(func(tx *bolt.Tx) error { @@ -105,14 +104,14 @@ func Test_migrateOptimalAttesterProtectionUp(t *testing.T) { for i := types.Epoch(1); i <= numEpochs; i++ { var sr [32]byte copy(sr[:], fmt.Sprintf("%d", i)) - newHist, err := history.setTargetData(ctx, i, &deprecatedHistoryData{ + newHist, err := history.setTargetData(i, &deprecatedHistoryData{ Source: i - 1, SigningRoot: sr[:], }) require.NoError(t, err) history = newHist } - newHist, err := history.setLatestEpochWritten(ctx, numEpochs) + newHist, err := history.setLatestEpochWritten(numEpochs) require.NoError(t, err) err = validatorDB.update(func(tx *bolt.Tx) error { @@ -134,12 +133,12 @@ func Test_migrateOptimalAttesterProtectionUp(t *testing.T) { // Write one more entry to the DB with the old format. var sr [32]byte copy(sr[:], fmt.Sprintf("%d", numEpochs+1)) - newHist, err = newHist.setTargetData(ctx, numEpochs+1, &deprecatedHistoryData{ + newHist, err = newHist.setTargetData(numEpochs+1, &deprecatedHistoryData{ Source: numEpochs, SigningRoot: sr[:], }) require.NoError(t, err) - newHist, err = newHist.setLatestEpochWritten(ctx, numEpochs+1) + newHist, err = newHist.setLatestEpochWritten(numEpochs + 1) require.NoError(t, err) err = validatorDB.update(func(tx *bolt.Tx) error { @@ -270,7 +269,6 @@ func Test_migrateOptimalAttesterProtectionDown(t *testing.T) { require.NoError(t, err) }, eval: func(t *testing.T, validatorDB *Store) { - ctx := context.Background() pubKeys := [][fieldparams.BLSPubkeyLength]byte{{1}, {2}} // Next up, we validate that we have indeed rolled back our data // into the old format for attesting history. @@ -280,7 +278,7 @@ func Test_migrateOptimalAttesterProtectionDown(t *testing.T) { encodedHistoryBytes := bkt.Get(pubKey[:]) require.NotNil(t, encodedHistoryBytes) attestingHistory := deprecatedEncodedAttestingHistory(encodedHistoryBytes) - highestEpoch, err := attestingHistory.getLatestEpochWritten(ctx) + highestEpoch, err := attestingHistory.getLatestEpochWritten() require.NoError(t, err) // Verify the highest epoch written is 50 from the setup stage. require.Equal(t, types.Epoch(50), highestEpoch) diff --git a/validator/db/kv/prune_attester_protection_test.go b/validator/db/kv/prune_attester_protection_test.go index 179c992914..e222016705 100644 --- a/validator/db/kv/prune_attester_protection_test.go +++ b/validator/db/kv/prune_attester_protection_test.go @@ -20,7 +20,7 @@ func TestPruneAttestations_NoPruning(t *testing.T) { // Write attesting history for every single epoch // since genesis to a specified number of epochs. numEpochs := params.BeaconConfig().SlashingProtectionPruningEpochs - 1 - err := setupAttestationsForEveryEpoch(t, validatorDB, pubKey, numEpochs) + err := setupAttestationsForEveryEpoch(validatorDB, pubKey, numEpochs) require.NoError(t, err) // Next, attempt to prune and realize that we still have all epochs intact @@ -51,7 +51,7 @@ func TestPruneAttestations_OK(t *testing.T) { // since genesis to SLASHING_PROTECTION_PRUNING_EPOCHS * 2. numEpochs := params.BeaconConfig().SlashingProtectionPruningEpochs * 2 for _, pk := range pks { - require.NoError(t, setupAttestationsForEveryEpoch(t, validatorDB, pk, numEpochs)) + require.NoError(t, setupAttestationsForEveryEpoch(validatorDB, pk, numEpochs)) } require.NoError(t, validatorDB.PruneAttestations(context.Background())) @@ -104,7 +104,7 @@ func BenchmarkPruneAttestations(b *testing.B) { for i := 0; i < b.N; i++ { b.StopTimer() for _, pk := range pks { - require.NoError(b, setupAttestationsForEveryEpoch(b, validatorDB, pk, numEpochs)) + require.NoError(b, setupAttestationsForEveryEpoch(validatorDB, pk, numEpochs)) } b.StartTimer() @@ -114,7 +114,7 @@ func BenchmarkPruneAttestations(b *testing.B) { // Saves attesting history for every (source, target = source + 1) pairs since genesis // up to a given number of epochs for a validator public key. -func setupAttestationsForEveryEpoch(t testing.TB, validatorDB *Store, pubKey [fieldparams.BLSPubkeyLength]byte, numEpochs types.Epoch) error { +func setupAttestationsForEveryEpoch(validatorDB *Store, pubKey [48]byte, numEpochs types.Epoch) error { return validatorDB.update(func(tx *bolt.Tx) error { bucket := tx.Bucket(pubKeysBucket) pkBucket, err := bucket.CreateBucketIfNotExists(pubKey[:]) diff --git a/validator/keymanager/remote-web3signer/internal/client_test.go b/validator/keymanager/remote-web3signer/internal/client_test.go index 4177b15261..9fc3637f00 100644 --- a/validator/keymanager/remote-web3signer/internal/client_test.go +++ b/validator/keymanager/remote-web3signer/internal/client_test.go @@ -108,9 +108,9 @@ func TestClient_Sign_400(t *testing.T) { func TestClient_GetPublicKeys_HappyPath(t *testing.T) { // public keys are returned hex encoded with 0x - json := `["0xa2b5aaad9c6efefe7bb9b1243a043404f3362937cfb6b31833929833173f476630ea2cfeb0d9ddf15f97ca8685948820"]` + j := `["0xa2b5aaad9c6efefe7bb9b1243a043404f3362937cfb6b31833929833173f476630ea2cfeb0d9ddf15f97ca8685948820"]` // create a new reader with that JSON - r := io.NopCloser(bytes.NewReader([]byte(json))) + r := io.NopCloser(bytes.NewReader([]byte(j))) mock := &mockTransport{mockResponse: &http.Response{ StatusCode: 200, Body: r, @@ -127,9 +127,9 @@ func TestClient_GetPublicKeys_HappyPath(t *testing.T) { func TestClient_GetPublicKeys_EncodingError(t *testing.T) { // public keys are returned hex encoded with 0x - json := `["a2b5aaad9c6efefe7bb9b1243a043404f3362937c","fb6b31833929833173f476630ea2cfe","b0d9ddf15fca8685948820"]` + j := `["a2b5aaad9c6efefe7bb9b1243a043404f3362937c","fb6b31833929833173f476630ea2cfe","b0d9ddf15fca8685948820"]` // create a new reader with that JSON - r := io.NopCloser(bytes.NewReader([]byte(json))) + r := io.NopCloser(bytes.NewReader([]byte(j))) mock := &mockTransport{mockResponse: &http.Response{ StatusCode: 200, Body: r, @@ -157,8 +157,8 @@ func TestClient_ReloadSignerKeys_HappyPath(t *testing.T) { // TODO: not really in use, should be revisited func TestClient_GetServerStatus_HappyPath(t *testing.T) { - json := `"some server status, not sure what it looks like, need to find some sample data"` - r := io.NopCloser(bytes.NewReader([]byte(json))) + j := `"some server status, not sure what it looks like, need to find some sample data"` + r := io.NopCloser(bytes.NewReader([]byte(j))) mock := &mockTransport{mockResponse: &http.Response{ StatusCode: 200, Body: r, diff --git a/validator/keymanager/remote-web3signer/keymanager.go b/validator/keymanager/remote-web3signer/keymanager.go index 44a160043c..ab9f5053eb 100644 --- a/validator/keymanager/remote-web3signer/keymanager.go +++ b/validator/keymanager/remote-web3signer/keymanager.go @@ -18,7 +18,7 @@ import ( ethpbservice "github.com/prysmaticlabs/prysm/proto/eth/service" validatorpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/validator-client" "github.com/prysmaticlabs/prysm/validator/keymanager" - remote_utils "github.com/prysmaticlabs/prysm/validator/keymanager/remote-utils" + remoteutils "github.com/prysmaticlabs/prysm/validator/keymanager/remote-utils" "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer/internal" web3signerv1 "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer/v1" log "github.com/sirupsen/logrus" @@ -250,7 +250,7 @@ func (km *Keymanager) SubscribeAccountChanges(pubKeysChan chan [][fieldparams.BL // ExtractKeystores is not supported for the remote-web3signer keymanager type. func (*Keymanager) ExtractKeystores( - ctx context.Context, publicKeys []bls.PublicKey, password string, + _ context.Context, _ []bls.PublicKey, _ string, ) ([]*keymanager.Keystore, error) { return nil, errors.New("extracting keys is not supported for a web3signer keymanager") } @@ -283,7 +283,7 @@ func (km *Keymanager) ListKeymanagerAccounts(ctx context.Context, cfg keymanager } else { fmt.Printf("Showing %d validator accounts\n", len(validatingPubKeys)) } - remote_utils.DisplayRemotePublicKeys(validatingPubKeys) + remoteutils.DisplayRemotePublicKeys(validatingPubKeys) return nil } diff --git a/validator/keymanager/remote/keymanager.go b/validator/keymanager/remote/keymanager.go index 80f466678f..e33a6ae3d4 100644 --- a/validator/keymanager/remote/keymanager.go +++ b/validator/keymanager/remote/keymanager.go @@ -23,7 +23,7 @@ import ( ethpbservice "github.com/prysmaticlabs/prysm/proto/eth/service" validatorpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/validator-client" "github.com/prysmaticlabs/prysm/validator/keymanager" - remote_utils "github.com/prysmaticlabs/prysm/validator/keymanager/remote-utils" + remoteutils "github.com/prysmaticlabs/prysm/validator/keymanager/remote-utils" "google.golang.org/grpc" "google.golang.org/grpc/credentials" ) @@ -273,7 +273,7 @@ func (km *Keymanager) SubscribeAccountChanges(pubKeysChan chan [][fieldparams.BL // ExtractKeystores is not supported for the remote keymanager type. func (*Keymanager) ExtractKeystores( - ctx context.Context, publicKeys []bls.PublicKey, password string, + _ context.Context, _ []bls.PublicKey, _ string, ) ([]*keymanager.Keystore, error) { return nil, errors.New("extracting keys not supported for a remote keymanager") } @@ -309,6 +309,6 @@ func ListKeymanagerAccountsImpl(ctx context.Context, cfg keymanager.ListKeymanag } else { fmt.Printf("Showing %d validator accounts\n", len(validatingPubKeys)) } - remote_utils.DisplayRemotePublicKeys(validatingPubKeys) + remoteutils.DisplayRemotePublicKeys(validatingPubKeys) return nil } diff --git a/validator/keymanager/remote/mock/mock_keymanager.go b/validator/keymanager/remote/mock/mock_keymanager.go index 9be8d383e6..744ff18301 100644 --- a/validator/keymanager/remote/mock/mock_keymanager.go +++ b/validator/keymanager/remote/mock/mock_keymanager.go @@ -65,7 +65,7 @@ func (m *MockKeymanager) ReloadPublicKeys(context.Context) ([][fieldparams.BLSPu // ExtractKeystores -- func (*MockKeymanager) ExtractKeystores( - ctx context.Context, publicKeys []bls.PublicKey, password string, + _ context.Context, _ []bls.PublicKey, _ string, ) ([]*keymanager.Keystore, error) { return nil, errors.New("extracting keys not supported for a remote keymanager") } diff --git a/validator/keymanager/types_test.go b/validator/keymanager/types_test.go index 68185269e5..0c9e8f3b24 100644 --- a/validator/keymanager/types_test.go +++ b/validator/keymanager/types_test.go @@ -11,7 +11,7 @@ import ( "github.com/prysmaticlabs/prysm/validator/keymanager/derived" "github.com/prysmaticlabs/prysm/validator/keymanager/local" "github.com/prysmaticlabs/prysm/validator/keymanager/remote" - remote_web3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" + remoteweb3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" ) var ( @@ -27,8 +27,8 @@ var ( _ = keymanager.Deleter(&local.Keymanager{}) _ = keymanager.Deleter(&derived.Keymanager{}) - _ = keymanager.PublicKeyAdder(&remote_web3signer.Keymanager{}) - _ = keymanager.PublicKeyDeleter(&remote_web3signer.Keymanager{}) + _ = keymanager.PublicKeyAdder(&remoteweb3signer.Keymanager{}) + _ = keymanager.PublicKeyDeleter(&remoteweb3signer.Keymanager{}) ) func TestKeystoreContainsPath(t *testing.T) { diff --git a/validator/node/node.go b/validator/node/node.go index 890718fc79..d74589fe4d 100644 --- a/validator/node/node.go +++ b/validator/node/node.go @@ -48,9 +48,9 @@ import ( "github.com/prysmaticlabs/prysm/validator/db/kv" g "github.com/prysmaticlabs/prysm/validator/graffiti" "github.com/prysmaticlabs/prysm/validator/keymanager/local" - remote_web3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" + remoteweb3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" "github.com/prysmaticlabs/prysm/validator/rpc" - validatorMiddleware "github.com/prysmaticlabs/prysm/validator/rpc/apimiddleware" + validatormiddleware "github.com/prysmaticlabs/prysm/validator/rpc/apimiddleware" "github.com/prysmaticlabs/prysm/validator/web" "github.com/sirupsen/logrus" "github.com/urfave/cli/v2" @@ -438,8 +438,8 @@ func (c *ValidatorClient) registerValidatorService(cliCtx *cli.Context) error { return c.services.RegisterService(v) } -func web3SignerConfig(cliCtx *cli.Context) (*remote_web3signer.SetupConfig, error) { - var web3signerConfig *remote_web3signer.SetupConfig +func web3SignerConfig(cliCtx *cli.Context) (*remoteweb3signer.SetupConfig, error) { + var web3signerConfig *remoteweb3signer.SetupConfig if cliCtx.IsSet(flags.Web3SignerURLFlag.Name) { urlStr := cliCtx.String(flags.Web3SignerURLFlag.Name) u, err := url.ParseRequestURI(urlStr) @@ -449,7 +449,7 @@ func web3SignerConfig(cliCtx *cli.Context) (*remote_web3signer.SetupConfig, erro if u.Scheme == "" || u.Host == "" { return nil, fmt.Errorf("web3signer url must be in the format of http(s)://host:port url used: %v", urlStr) } - web3signerConfig = &remote_web3signer.SetupConfig{ + web3signerConfig = &remoteweb3signer.SetupConfig{ BaseEndpoint: u.String(), GenesisValidatorsRoot: nil, } @@ -712,7 +712,7 @@ func (c *ValidatorClient) registerRPCGatewayService(cliCtx *cli.Context) error { gateway.WithMaxCallRecvMsgSize(maxCallSize), gateway.WithPbHandlers([]*gateway.PbMux{pbHandler}), gateway.WithAllowedOrigins(allowedOrigins), - gateway.WithApiMiddleware(&validatorMiddleware.ValidatorEndpointFactory{}), + gateway.WithApiMiddleware(&validatormiddleware.ValidatorEndpointFactory{}), gateway.WithMuxHandler(muxHandler), gateway.WithTimeout(uint64(timeout)), } diff --git a/validator/node/node_test.go b/validator/node/node_test.go index a480db9c1b..0617b7fb81 100644 --- a/validator/node/node_test.go +++ b/validator/node/node_test.go @@ -16,15 +16,15 @@ import ( "github.com/ethereum/go-ethereum/common/hexutil" "github.com/prysmaticlabs/prysm/cmd/validator/flags" fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams" - validator_service_config "github.com/prysmaticlabs/prysm/config/validator/service" + validatorserviceconfig "github.com/prysmaticlabs/prysm/config/validator/service" "github.com/prysmaticlabs/prysm/encoding/bytesutil" "github.com/prysmaticlabs/prysm/testing/assert" "github.com/prysmaticlabs/prysm/testing/require" "github.com/prysmaticlabs/prysm/validator/accounts" "github.com/prysmaticlabs/prysm/validator/accounts/wallet" "github.com/prysmaticlabs/prysm/validator/keymanager" - remote_web3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" - logTest "github.com/sirupsen/logrus/hooks/test" + remoteweb3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" + logtest "github.com/sirupsen/logrus/hooks/test" "github.com/urfave/cli/v2" ) @@ -48,8 +48,8 @@ func TestNode_Builds(t *testing.T) { set.String("keymanager-kind", "imported", "keymanager kind") set.String("verbosity", "debug", "log verbosity") require.NoError(t, set.Set(flags.WalletPasswordFileFlag.Name, passwordFile)) - context := cli.NewContext(&app, set, nil) - _, err := accounts.CreateWalletWithKeymanager(context.Context, &accounts.CreateWalletConfig{ + ctx := cli.NewContext(&app, set, nil) + _, err := accounts.CreateWalletWithKeymanager(ctx.Context, &accounts.CreateWalletConfig{ WalletCfg: &wallet.Config{ WalletDir: dir, KeymanagerKind: keymanager.Local, @@ -58,7 +58,7 @@ func TestNode_Builds(t *testing.T) { }) require.NoError(t, err) - valClient, err := NewValidatorClient(context) + valClient, err := NewValidatorClient(ctx) require.NoError(t, err, "Failed to create ValidatorClient") err = valClient.db.Close() require.NoError(t, err) @@ -66,7 +66,7 @@ func TestNode_Builds(t *testing.T) { // TestClearDB tests clearing the database func TestClearDB(t *testing.T) { - hook := logTest.NewGlobal() + hook := logtest.NewGlobal() tmp := filepath.Join(t.TempDir(), "datadirtest") require.NoError(t, clearDB(context.Background(), tmp, true)) require.LogsContain(t, hook, "Removing database") @@ -89,7 +89,7 @@ func TestWeb3SignerConfig(t *testing.T) { tests := []struct { name string args args - want *remote_web3signer.SetupConfig + want *remoteweb3signer.SetupConfig wantErrMsg string }{ { @@ -99,7 +99,7 @@ func TestWeb3SignerConfig(t *testing.T) { publicKeysOrURL: "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c," + "0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b", }, - want: &remote_web3signer.SetupConfig{ + want: &remoteweb3signer.SetupConfig{ BaseEndpoint: "http://localhost:8545", GenesisValidatorsRoot: nil, PublicKeysURL: "", @@ -115,7 +115,7 @@ func TestWeb3SignerConfig(t *testing.T) { baseURL: "http://localhost:8545", publicKeysOrURL: "http://localhost:8545/api/v1/eth2/publicKeys", }, - want: &remote_web3signer.SetupConfig{ + want: &remoteweb3signer.SetupConfig{ BaseEndpoint: "http://localhost:8545", GenesisValidatorsRoot: nil, PublicKeysURL: "http://localhost:8545/api/v1/eth2/publicKeys", @@ -193,7 +193,7 @@ func newWeb3SignerCli(t *testing.T, baseUrl string, publicKeysOrURL string) *cli } func TestProposerSettings(t *testing.T) { - hook := logTest.NewGlobal() + hook := logtest.NewGlobal() type proposerSettingsFlag struct { dir string @@ -207,7 +207,7 @@ func TestProposerSettings(t *testing.T) { tests := []struct { name string args args - want func() *validator_service_config.ProposerSettings + want func() *validatorserviceconfig.ProposerSettings urlResponse string wantErr string wantLog string @@ -221,17 +221,17 @@ func TestProposerSettings(t *testing.T) { defaultfee: "", }, }, - want: func() *validator_service_config.ProposerSettings { + want: func() *validatorserviceconfig.ProposerSettings { key1, err := hexutil.Decode("0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a") require.NoError(t, err) - return &validator_service_config.ProposerSettings{ - ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validator_service_config.ProposerOption{ + return &validatorserviceconfig.ProposerSettings{ + ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption{ bytesutil.ToBytes48(key1): { FeeRecipient: common.HexToAddress("0xae967917c465db8578ca9024c205720b1a3651A9"), GasLimit: params.BeaconConfig().DefaultBuilderGasLimit, }, }, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0xae967917c465db8578ca9024c205720b1a3651A9"), GasLimit: params.BeaconConfig().DefaultBuilderGasLimit, }, @@ -249,13 +249,13 @@ func TestProposerSettings(t *testing.T) { defaultfee: "", }, }, - want: func() *validator_service_config.ProposerSettings { + want: func() *validatorserviceconfig.ProposerSettings { key1, err := hexutil.Decode("0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a") require.NoError(t, err) key2, err := hexutil.Decode("0xb057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7b") require.NoError(t, err) - return &validator_service_config.ProposerSettings{ - ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validator_service_config.ProposerOption{ + return &validatorserviceconfig.ProposerSettings{ + ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption{ bytesutil.ToBytes48(key1): { FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"), GasLimit: params.BeaconConfig().DefaultBuilderGasLimit, @@ -265,7 +265,7 @@ func TestProposerSettings(t *testing.T) { GasLimit: params.BeaconConfig().DefaultBuilderGasLimit, }, }, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"), GasLimit: params.BeaconConfig().DefaultBuilderGasLimit, }, @@ -282,17 +282,17 @@ func TestProposerSettings(t *testing.T) { defaultfee: "", }, }, - want: func() *validator_service_config.ProposerSettings { + want: func() *validatorserviceconfig.ProposerSettings { key1, err := hexutil.Decode("0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a") require.NoError(t, err) - return &validator_service_config.ProposerSettings{ - ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validator_service_config.ProposerOption{ + return &validatorserviceconfig.ProposerSettings{ + ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption{ bytesutil.ToBytes48(key1): { FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"), GasLimit: params.BeaconConfig().DefaultBuilderGasLimit, }, }, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"), GasLimit: params.BeaconConfig().DefaultBuilderGasLimit, }, @@ -309,17 +309,17 @@ func TestProposerSettings(t *testing.T) { defaultfee: "", }, }, - want: func() *validator_service_config.ProposerSettings { + want: func() *validatorserviceconfig.ProposerSettings { key1, err := hexutil.Decode("0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a") require.NoError(t, err) - return &validator_service_config.ProposerSettings{ - ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validator_service_config.ProposerOption{ + return &validatorserviceconfig.ProposerSettings{ + ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption{ bytesutil.ToBytes48(key1): { FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"), GasLimit: uint64(40000000), }, }, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"), GasLimit: uint64(45000000), }, @@ -336,10 +336,10 @@ func TestProposerSettings(t *testing.T) { defaultfee: "0x6e35733c5af9B61374A128e6F85f553aF09ff89A", }, }, - want: func() *validator_service_config.ProposerSettings { - return &validator_service_config.ProposerSettings{ + want: func() *validatorserviceconfig.ProposerSettings { + return &validatorserviceconfig.ProposerSettings{ ProposeConfig: nil, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"), GasLimit: params.BeaconConfig().DefaultBuilderGasLimit, }, @@ -356,17 +356,17 @@ func TestProposerSettings(t *testing.T) { defaultfee: "0x6e35733c5af9B61374A128e6F85f553aF09ff89B", }, }, - want: func() *validator_service_config.ProposerSettings { + want: func() *validatorserviceconfig.ProposerSettings { key1, err := hexutil.Decode("0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a") require.NoError(t, err) - return &validator_service_config.ProposerSettings{ - ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validator_service_config.ProposerOption{ + return &validatorserviceconfig.ProposerSettings{ + ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption{ bytesutil.ToBytes48(key1): { FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"), GasLimit: params.BeaconConfig().DefaultBuilderGasLimit, }, }, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"), GasLimit: params.BeaconConfig().DefaultBuilderGasLimit, }, @@ -383,7 +383,7 @@ func TestProposerSettings(t *testing.T) { defaultfee: "", }, }, - want: func() *validator_service_config.ProposerSettings { + want: func() *validatorserviceconfig.ProposerSettings { return nil }, wantErr: "", @@ -397,7 +397,7 @@ func TestProposerSettings(t *testing.T) { defaultfee: "", }, }, - want: func() *validator_service_config.ProposerSettings { + want: func() *validatorserviceconfig.ProposerSettings { return nil }, wantErr: "failed to unmarshal yaml file", @@ -411,8 +411,8 @@ func TestProposerSettings(t *testing.T) { defaultfee: "", }, }, - want: func() *validator_service_config.ProposerSettings { - return &validator_service_config.ProposerSettings{} + want: func() *validatorserviceconfig.ProposerSettings { + return &validatorserviceconfig.ProposerSettings{} }, wantErr: "cannot specify both", }, diff --git a/validator/rpc/beacon.go b/validator/rpc/beacon.go index 8042a2cfd1..fd0e641318 100644 --- a/validator/rpc/beacon.go +++ b/validator/rpc/beacon.go @@ -6,9 +6,9 @@ import ( "github.com/golang/protobuf/ptypes/empty" middleware "github.com/grpc-ecosystem/go-grpc-middleware" - grpc_retry "github.com/grpc-ecosystem/go-grpc-middleware/retry" - grpc_opentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing" - grpc_prometheus "github.com/grpc-ecosystem/go-grpc-prometheus" + grpcretry "github.com/grpc-ecosystem/go-grpc-middleware/retry" + grpcopentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing" + grpcprometheus "github.com/grpc-ecosystem/go-grpc-prometheus" "github.com/pkg/errors" grpcutil "github.com/prysmaticlabs/prysm/api/grpc" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" @@ -21,9 +21,9 @@ import ( // Initialize a client connect to a beacon node gRPC endpoint. func (s *Server) registerBeaconClient() error { streamInterceptor := grpc.WithStreamInterceptor(middleware.ChainStreamClient( - grpc_opentracing.StreamClientInterceptor(), - grpc_prometheus.StreamClientInterceptor, - grpc_retry.StreamClientInterceptor(), + grpcopentracing.StreamClientInterceptor(), + grpcprometheus.StreamClientInterceptor, + grpcretry.StreamClientInterceptor(), )) dialOpts := client.ConstructDialOptions( s.clientMaxCallRecvMsgSize, diff --git a/validator/rpc/server.go b/validator/rpc/server.go index a0a75ffb49..ff2b864826 100644 --- a/validator/rpc/server.go +++ b/validator/rpc/server.go @@ -9,8 +9,8 @@ import ( middleware "github.com/grpc-ecosystem/go-grpc-middleware" recovery "github.com/grpc-ecosystem/go-grpc-middleware/recovery" - grpc_opentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing" - grpc_prometheus "github.com/grpc-ecosystem/go-grpc-prometheus" + grpcopentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing" + grpcprometheus "github.com/grpc-ecosystem/go-grpc-prometheus" "github.com/prysmaticlabs/prysm/async/event" "github.com/prysmaticlabs/prysm/io/logs" "github.com/prysmaticlabs/prysm/monitoring/tracing" @@ -144,12 +144,12 @@ func (s *Server) Start() { recovery.UnaryServerInterceptor( recovery.WithRecoveryHandlerContext(tracing.RecoveryHandlerFunc), ), - grpc_prometheus.UnaryServerInterceptor, - grpc_opentracing.UnaryServerInterceptor(), + grpcprometheus.UnaryServerInterceptor, + grpcopentracing.UnaryServerInterceptor(), s.JWTInterceptor(), )), } - grpc_prometheus.EnableHandlingTimeHistogram() + grpcprometheus.EnableHandlingTimeHistogram() if s.withCert != "" && s.withKey != "" { creds, err := credentials.NewServerTLSFromFile(s.withCert, s.withKey) diff --git a/validator/rpc/standard_api.go b/validator/rpc/standard_api.go index 6af27819cb..fa05421fd6 100644 --- a/validator/rpc/standard_api.go +++ b/validator/rpc/standard_api.go @@ -390,7 +390,7 @@ func groupDeleteRemoteKeysErrors(req *ethpbservice.DeleteRemoteKeysRequest, erro } // ListFeeRecipientByPubkey returns the public key to eth address mapping object to the end user. -func (s *Server) ListFeeRecipientByPubkey(ctx context.Context, req *ethpbservice.PubkeyRequest) (*ethpbservice.GetFeeRecipientByPubkeyResponse, error) { +func (s *Server) ListFeeRecipientByPubkey(_ context.Context, req *ethpbservice.PubkeyRequest) (*ethpbservice.GetFeeRecipientByPubkeyResponse, error) { if s.validatorService == nil { return nil, status.Error(codes.FailedPrecondition, "Validator service not ready") } diff --git a/validator/rpc/standard_api_test.go b/validator/rpc/standard_api_test.go index 76f239eaf6..b31cf642fd 100644 --- a/validator/rpc/standard_api_test.go +++ b/validator/rpc/standard_api_test.go @@ -14,7 +14,7 @@ import ( "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams" "github.com/prysmaticlabs/prysm/config/params" - validator_service_config "github.com/prysmaticlabs/prysm/config/validator/service" + validatorserviceconfig "github.com/prysmaticlabs/prysm/config/validator/service" "github.com/prysmaticlabs/prysm/crypto/bls" "github.com/prysmaticlabs/prysm/encoding/bytesutil" ethpbservice "github.com/prysmaticlabs/prysm/proto/eth/service" @@ -29,7 +29,7 @@ import ( "github.com/prysmaticlabs/prysm/validator/db/kv" "github.com/prysmaticlabs/prysm/validator/keymanager" "github.com/prysmaticlabs/prysm/validator/keymanager/derived" - remote_web3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" + remoteweb3signer "github.com/prysmaticlabs/prysm/validator/keymanager/remote-web3signer" "github.com/prysmaticlabs/prysm/validator/slashing-protection-history/format" mocks "github.com/prysmaticlabs/prysm/validator/testing" keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4" @@ -245,7 +245,7 @@ func TestServer_ImportKeystores_WrongKeymanagerKind(t *testing.T) { w := wallet.NewWalletForWeb3Signer() root := make([]byte, fieldparams.RootLength) root[0] = 1 - km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false, Web3SignerConfig: &remote_web3signer.SetupConfig{ + km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false, Web3SignerConfig: &remoteweb3signer.SetupConfig{ BaseEndpoint: "http://example.com", GenesisValidatorsRoot: root, PublicKeysURL: "http://example.com/public_keys", @@ -461,7 +461,7 @@ func TestServer_DeleteKeystores_WrongKeymanagerKind(t *testing.T) { root := make([]byte, fieldparams.RootLength) root[0] = 1 km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false, - Web3SignerConfig: &remote_web3signer.SetupConfig{ + Web3SignerConfig: &remoteweb3signer.SetupConfig{ BaseEndpoint: "http://example.com", GenesisValidatorsRoot: root, PublicKeysURL: "http://example.com/public_keys", @@ -545,7 +545,7 @@ func TestServer_ListRemoteKeys(t *testing.T) { bytevalue, err := hexutil.Decode("0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a") require.NoError(t, err) pubkeys := [][fieldparams.BLSPubkeyLength]byte{bytesutil.ToBytes48(bytevalue)} - config := &remote_web3signer.SetupConfig{ + config := &remoteweb3signer.SetupConfig{ BaseEndpoint: "http://example.com", GenesisValidatorsRoot: root, ProvidedPublicKeys: pubkeys, @@ -587,7 +587,7 @@ func TestServer_ImportRemoteKeys(t *testing.T) { w := wallet.NewWalletForWeb3Signer() root := make([]byte, fieldparams.RootLength) root[0] = 1 - config := &remote_web3signer.SetupConfig{ + config := &remoteweb3signer.SetupConfig{ BaseEndpoint: "http://example.com", GenesisValidatorsRoot: root, ProvidedPublicKeys: nil, @@ -645,7 +645,7 @@ func TestServer_DeleteRemoteKeys(t *testing.T) { bytevalue, err := hexutil.Decode("0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a") require.NoError(t, err) pubkeys := [][fieldparams.BLSPubkeyLength]byte{bytesutil.ToBytes48(bytevalue)} - config := &remote_web3signer.SetupConfig{ + config := &remoteweb3signer.SetupConfig{ BaseEndpoint: "http://example.com", GenesisValidatorsRoot: root, ProvidedPublicKeys: pubkeys, @@ -698,19 +698,19 @@ func TestServer_ListFeeRecipientByPubkey(t *testing.T) { tests := []struct { name string - args *validator_service_config.ProposerSettings + args *validatorserviceconfig.ProposerSettings want *want wantErr bool }{ { name: "Happy Path Test", - args: &validator_service_config.ProposerSettings{ - ProposeConfig: map[[48]byte]*validator_service_config.ProposerOption{ + args: &validatorserviceconfig.ProposerSettings{ + ProposeConfig: map[[48]byte]*validatorserviceconfig.ProposerOption{ bytesutil.ToBytes48(byteval): { FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455012BFEBf6177F1D2e9738D9"), }, }, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455012BFEBf6177F1D2e9738D9"), }, }, @@ -754,7 +754,7 @@ func TestServer_SetFeeRecipientByPubkey(t *testing.T) { tests := []struct { name string args string - proposerSettings *validator_service_config.ProposerSettings + proposerSettings *validatorserviceconfig.ProposerSettings want *want wantErr bool }{ @@ -793,19 +793,19 @@ func TestServer_DeleteFeeRecipientByPubkey(t *testing.T) { } tests := []struct { name string - proposerSettings *validator_service_config.ProposerSettings + proposerSettings *validatorserviceconfig.ProposerSettings want *want wantErr bool }{ { name: "Happy Path Test", - proposerSettings: &validator_service_config.ProposerSettings{ - ProposeConfig: map[[48]byte]*validator_service_config.ProposerOption{ + proposerSettings: &validatorserviceconfig.ProposerSettings{ + ProposeConfig: map[[48]byte]*validatorserviceconfig.ProposerOption{ bytesutil.ToBytes48(byteval): { FeeRecipient: common.HexToAddress("0x055Fb65722E7b2455012BFEBf6177F1D2e9738D5"), }, }, - DefaultConfig: &validator_service_config.ProposerOption{ + DefaultConfig: &validatorserviceconfig.ProposerOption{ FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455012BFEBf6177F1D2e9738D9"), }, }, diff --git a/validator/testing/mock_slasher.go b/validator/testing/mock_slasher.go index 94f19a51a8..c200f7a717 100644 --- a/validator/testing/mock_slasher.go +++ b/validator/testing/mock_slasher.go @@ -18,7 +18,7 @@ type MockSlasher struct { } // HighestAttestations will return an empty array of attestations. -func (MockSlasher) HighestAttestations(ctx context.Context, req *eth.HighestAttestationRequest, _ ...grpc.CallOption) (*eth.HighestAttestationResponse, error) { +func (MockSlasher) HighestAttestations(_ context.Context, _ *eth.HighestAttestationRequest, _ ...grpc.CallOption) (*eth.HighestAttestationResponse, error) { return ð.HighestAttestationResponse{ Attestations: nil, }, nil