diff --git a/beacon-chain/core/helpers/BUILD.bazel b/beacon-chain/core/helpers/BUILD.bazel index 78b3e8bb44..f49a5ecaee 100644 --- a/beacon-chain/core/helpers/BUILD.bazel +++ b/beacon-chain/core/helpers/BUILD.bazel @@ -50,6 +50,8 @@ go_test( "attestation_test.go", "beacon_committee_test.go", "block_test.go", + "private_access_fuzz_noop_test.go", # keep + "private_access_test.go", "randao_test.go", "rewards_penalties_test.go", "shuffle_test.go", diff --git a/beacon-chain/core/helpers/beacon_committee.go b/beacon-chain/core/helpers/beacon_committee.go index a5b16367f8..715e490b7a 100644 --- a/beacon-chain/core/helpers/beacon_committee.go +++ b/beacon-chain/core/helpers/beacon_committee.go @@ -140,7 +140,7 @@ func BeaconCommittee( } count := committeesPerSlot * uint64(params.BeaconConfig().SlotsPerEpoch) - return computeCommittee(validatorIndices, seed, indexOffset, count) + return ComputeCommittee(validatorIndices, seed, indexOffset, count) } // CommitteeAssignmentContainer represents a committee list, committee index, and to be attested slot for a given epoch. @@ -359,7 +359,7 @@ func UpdateProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaco if err != nil { return err } - proposerIndices, err := precomputeProposerIndices(state, indices, epoch) + proposerIndices, err := PrecomputeProposerIndices(state, indices, epoch) if err != nil { return err } @@ -409,7 +409,7 @@ func ClearCache() { balanceCache.Clear() } -// computeCommittee returns the requested shuffled committee out of the total committees using +// ComputeCommittee returns the requested shuffled committee out of the total committees using // validator indices and seed. // // Spec pseudocode definition: @@ -424,7 +424,7 @@ func ClearCache() { // start = (len(indices) * index) // count // end = (len(indices) * uint64(index + 1)) // count // return [indices[compute_shuffled_index(uint64(i), uint64(len(indices)), seed)] for i in range(start, end)] -func computeCommittee( +func ComputeCommittee( indices []primitives.ValidatorIndex, seed [32]byte, index, count uint64, @@ -451,9 +451,9 @@ func computeCommittee( return shuffledList[start:end], nil } -// This computes proposer indices of the current epoch and returns a list of proposer indices, +// PrecomputeProposerIndices computes proposer indices of the current epoch and returns a list of proposer indices, // the index of the list represents the slot number. -func precomputeProposerIndices(state state.ReadOnlyBeaconState, activeIndices []primitives.ValidatorIndex, e primitives.Epoch) ([]primitives.ValidatorIndex, error) { +func PrecomputeProposerIndices(state state.ReadOnlyBeaconState, activeIndices []primitives.ValidatorIndex, e primitives.Epoch) ([]primitives.ValidatorIndex, error) { hashFunc := hash.CustomSHA256Hasher() proposerIndices := make([]primitives.ValidatorIndex, params.BeaconConfig().SlotsPerEpoch) diff --git a/beacon-chain/core/helpers/beacon_committee_test.go b/beacon-chain/core/helpers/beacon_committee_test.go index 2934a1274e..5de5d1bf4e 100644 --- a/beacon-chain/core/helpers/beacon_committee_test.go +++ b/beacon-chain/core/helpers/beacon_committee_test.go @@ -1,4 +1,4 @@ -package helpers +package helpers_test import ( "context" @@ -7,6 +7,7 @@ import ( "testing" "github.com/prysmaticlabs/go-bitfield" + "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers" "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time" state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native" "github.com/prysmaticlabs/prysm/v5/config/params" @@ -21,7 +22,7 @@ import ( ) func TestComputeCommittee_WithoutCache(t *testing.T) { - ClearCache() + helpers.ClearCache() // Create 10 committees committeeCount := uint64(10) @@ -48,16 +49,16 @@ func TestComputeCommittee_WithoutCache(t *testing.T) { require.NoError(t, err) epoch := time.CurrentEpoch(state) - indices, err := ActiveValidatorIndices(context.Background(), state, epoch) + indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch) require.NoError(t, err) - seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) + seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) require.NoError(t, err) - committees, err := computeCommittee(indices, seed, 0, 1 /* Total committee*/) + committees, err := helpers.ComputeCommittee(indices, seed, 0, 1 /* Total committee*/) assert.NoError(t, err, "Could not compute committee") // Test shuffled indices are correct for index 5 committee index := uint64(5) - committee5, err := computeCommittee(indices, seed, index, committeeCount) + committee5, err := helpers.ComputeCommittee(indices, seed, index, committeeCount) assert.NoError(t, err, "Could not compute committee") start := slice.SplitOffset(validatorCount, committeeCount, index) end := slice.SplitOffset(validatorCount, committeeCount, index+1) @@ -65,7 +66,7 @@ func TestComputeCommittee_WithoutCache(t *testing.T) { // Test shuffled indices are correct for index 9 committee index = uint64(9) - committee9, err := computeCommittee(indices, seed, index, committeeCount) + committee9, err := helpers.ComputeCommittee(indices, seed, index, committeeCount) assert.NoError(t, err, "Could not compute committee") start = slice.SplitOffset(validatorCount, committeeCount, index) end = slice.SplitOffset(validatorCount, committeeCount, index+1) @@ -73,42 +74,42 @@ func TestComputeCommittee_WithoutCache(t *testing.T) { } func TestComputeCommittee_RegressionTest(t *testing.T) { - ClearCache() + helpers.ClearCache() indices := []primitives.ValidatorIndex{1, 3, 8, 16, 18, 19, 20, 23, 30, 35, 43, 46, 47, 54, 56, 58, 69, 70, 71, 83, 84, 85, 91, 96, 100, 103, 105, 106, 112, 121, 127, 128, 129, 140, 142, 144, 146, 147, 149, 152, 153, 154, 157, 160, 173, 175, 180, 182, 188, 189, 191, 194, 201, 204, 217, 221, 226, 228, 230, 231, 239, 241, 249, 250, 255} seed := [32]byte{68, 110, 161, 250, 98, 230, 161, 172, 227, 226, 99, 11, 138, 124, 201, 134, 38, 197, 0, 120, 6, 165, 122, 34, 19, 216, 43, 226, 210, 114, 165, 183} index := uint64(215) count := uint64(32) - _, err := computeCommittee(indices, seed, index, count) + _, err := helpers.ComputeCommittee(indices, seed, index, count) require.ErrorContains(t, "index out of range", err) } func TestVerifyBitfieldLength_OK(t *testing.T) { - ClearCache() + helpers.ClearCache() bf := bitfield.Bitlist{0xFF, 0x01} committeeSize := uint64(8) - assert.NoError(t, VerifyBitfieldLength(bf, committeeSize), "Bitfield is not validated when it was supposed to be") + assert.NoError(t, helpers.VerifyBitfieldLength(bf, committeeSize), "Bitfield is not validated when it was supposed to be") bf = bitfield.Bitlist{0xFF, 0x07} committeeSize = 10 - assert.NoError(t, VerifyBitfieldLength(bf, committeeSize), "Bitfield is not validated when it was supposed to be") + assert.NoError(t, helpers.VerifyBitfieldLength(bf, committeeSize), "Bitfield is not validated when it was supposed to be") } func TestCommitteeAssignments_CannotRetrieveFutureEpoch(t *testing.T) { - ClearCache() + helpers.ClearCache() epoch := primitives.Epoch(1) state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{ Slot: 0, // Epoch 0. }) require.NoError(t, err) - _, _, err = CommitteeAssignments(context.Background(), state, epoch+1) + _, _, err = helpers.CommitteeAssignments(context.Background(), state, epoch+1) assert.ErrorContains(t, "can't be greater than next epoch", err) } func TestCommitteeAssignments_NoProposerForSlot0(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch) for i := 0; i < len(validators); i++ { @@ -127,7 +128,7 @@ func TestCommitteeAssignments_NoProposerForSlot0(t *testing.T) { RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector), }) require.NoError(t, err) - _, proposerIndexToSlots, err := CommitteeAssignments(context.Background(), state, 0) + _, proposerIndexToSlots, err := helpers.CommitteeAssignments(context.Background(), state, 0) require.NoError(t, err, "Failed to determine CommitteeAssignments") for _, ss := range proposerIndexToSlots { for _, s := range ss { @@ -198,9 +199,9 @@ func TestCommitteeAssignments_CanRetrieve(t *testing.T) { for i, tt := range tests { t.Run(fmt.Sprintf("%d", i), func(t *testing.T) { - ClearCache() + helpers.ClearCache() - validatorIndexToCommittee, proposerIndexToSlots, err := CommitteeAssignments(context.Background(), state, slots.ToEpoch(tt.slot)) + validatorIndexToCommittee, proposerIndexToSlots, err := helpers.CommitteeAssignments(context.Background(), state, slots.ToEpoch(tt.slot)) require.NoError(t, err, "Failed to determine CommitteeAssignments") cac := validatorIndexToCommittee[tt.index] assert.Equal(t, tt.committeeIndex, cac.CommitteeIndex, "Unexpected committeeIndex for validator index %d", tt.index) @@ -215,7 +216,7 @@ func TestCommitteeAssignments_CanRetrieve(t *testing.T) { } func TestCommitteeAssignments_CannotRetrieveFuture(t *testing.T) { - ClearCache() + helpers.ClearCache() // Initialize test with 256 validators, each slot and each index gets 4 validators. validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch) @@ -237,17 +238,17 @@ func TestCommitteeAssignments_CannotRetrieveFuture(t *testing.T) { RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector), }) require.NoError(t, err) - _, proposerIndxs, err := CommitteeAssignments(context.Background(), state, time.CurrentEpoch(state)) + _, proposerIndxs, err := helpers.CommitteeAssignments(context.Background(), state, time.CurrentEpoch(state)) require.NoError(t, err) require.NotEqual(t, 0, len(proposerIndxs), "wanted non-zero proposer index set") - _, proposerIndxs, err = CommitteeAssignments(context.Background(), state, time.CurrentEpoch(state)+1) + _, proposerIndxs, err = helpers.CommitteeAssignments(context.Background(), state, time.CurrentEpoch(state)+1) require.NoError(t, err) require.NotEqual(t, 0, len(proposerIndxs), "wanted non-zero proposer index set") } func TestCommitteeAssignments_CannotRetrieveOlderThanSlotsPerHistoricalRoot(t *testing.T) { - ClearCache() + helpers.ClearCache() // Initialize test with 256 validators, each slot and each index gets 4 validators. validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch) @@ -263,12 +264,12 @@ func TestCommitteeAssignments_CannotRetrieveOlderThanSlotsPerHistoricalRoot(t *t RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector), }) require.NoError(t, err) - _, _, err = CommitteeAssignments(context.Background(), state, 0) + _, _, err = helpers.CommitteeAssignments(context.Background(), state, 0) require.ErrorContains(t, "start slot 0 is smaller than the minimum valid start slot 1", err) } func TestCommitteeAssignments_EverySlotHasMin1Proposer(t *testing.T) { - ClearCache() + helpers.ClearCache() // Initialize test with 256 validators, each slot and each index gets 4 validators. validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch) @@ -285,7 +286,7 @@ func TestCommitteeAssignments_EverySlotHasMin1Proposer(t *testing.T) { }) require.NoError(t, err) epoch := primitives.Epoch(1) - _, proposerIndexToSlots, err := CommitteeAssignments(context.Background(), state, epoch) + _, proposerIndexToSlots, err := helpers.CommitteeAssignments(context.Background(), state, epoch) require.NoError(t, err, "Failed to determine CommitteeAssignments") slotsWithProposers := make(map[primitives.Slot]bool) @@ -391,10 +392,10 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) { } for i, tt := range tests { - ClearCache() + helpers.ClearCache() require.NoError(t, state.SetSlot(tt.stateSlot)) - err := VerifyAttestationBitfieldLengths(context.Background(), state, tt.attestation) + err := helpers.VerifyAttestationBitfieldLengths(context.Background(), state, tt.attestation) if tt.verificationFailure { assert.NotNil(t, err, "Verification succeeded when it was supposed to fail") } else { @@ -404,7 +405,7 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) { } func TestUpdateCommitteeCache_CanUpdate(t *testing.T) { - ClearCache() + helpers.ClearCache() validatorCount := params.BeaconConfig().MinGenesisActiveValidatorCount validators := make([]*ethpb.Validator, validatorCount) @@ -421,20 +422,20 @@ func TestUpdateCommitteeCache_CanUpdate(t *testing.T) { RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector), }) require.NoError(t, err) - require.NoError(t, UpdateCommitteeCache(context.Background(), state, time.CurrentEpoch(state))) + require.NoError(t, helpers.UpdateCommitteeCache(context.Background(), state, time.CurrentEpoch(state))) epoch := primitives.Epoch(0) idx := primitives.CommitteeIndex(1) - seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) + seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) require.NoError(t, err) - indices, err = committeeCache.Committee(context.Background(), params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epoch)), seed, idx) + indices, err = helpers.CommitteeCache().Committee(context.Background(), params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epoch)), seed, idx) require.NoError(t, err) assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(indices)), "Did not save correct indices lengths") } func TestUpdateCommitteeCache_CanUpdateAcrossEpochs(t *testing.T) { - ClearCache() + helpers.ClearCache() validatorCount := params.BeaconConfig().MinGenesisActiveValidatorCount validators := make([]*ethpb.Validator, validatorCount) @@ -452,19 +453,19 @@ func TestUpdateCommitteeCache_CanUpdateAcrossEpochs(t *testing.T) { }) require.NoError(t, err) e := time.CurrentEpoch(state) - require.NoError(t, UpdateCommitteeCache(context.Background(), state, e)) + require.NoError(t, helpers.UpdateCommitteeCache(context.Background(), state, e)) - seed, err := Seed(state, e, params.BeaconConfig().DomainBeaconAttester) + seed, err := helpers.Seed(state, e, params.BeaconConfig().DomainBeaconAttester) require.NoError(t, err) - require.Equal(t, true, committeeCache.HasEntry(string(seed[:]))) + require.Equal(t, true, helpers.CommitteeCache().HasEntry(string(seed[:]))) - nextSeed, err := Seed(state, e+1, params.BeaconConfig().DomainBeaconAttester) + nextSeed, err := helpers.Seed(state, e+1, params.BeaconConfig().DomainBeaconAttester) require.NoError(t, err) - require.Equal(t, false, committeeCache.HasEntry(string(nextSeed[:]))) + require.Equal(t, false, helpers.CommitteeCache().HasEntry(string(nextSeed[:]))) - require.NoError(t, UpdateCommitteeCache(context.Background(), state, e+1)) + require.NoError(t, helpers.UpdateCommitteeCache(context.Background(), state, e+1)) - require.Equal(t, true, committeeCache.HasEntry(string(nextSeed[:]))) + require.Equal(t, true, helpers.CommitteeCache().HasEntry(string(nextSeed[:]))) } func BenchmarkComputeCommittee300000_WithPreCache(b *testing.B) { @@ -481,20 +482,20 @@ func BenchmarkComputeCommittee300000_WithPreCache(b *testing.B) { require.NoError(b, err) epoch := time.CurrentEpoch(state) - indices, err := ActiveValidatorIndices(context.Background(), state, epoch) + indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch) require.NoError(b, err) - seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) + seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) require.NoError(b, err) index := uint64(3) - _, err = computeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) + _, err = helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) if err != nil { panic(err) } b.ResetTimer() for n := 0; n < b.N; n++ { - _, err := computeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) + _, err := helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) if err != nil { panic(err) } @@ -515,20 +516,20 @@ func BenchmarkComputeCommittee3000000_WithPreCache(b *testing.B) { require.NoError(b, err) epoch := time.CurrentEpoch(state) - indices, err := ActiveValidatorIndices(context.Background(), state, epoch) + indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch) require.NoError(b, err) - seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) + seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) require.NoError(b, err) index := uint64(3) - _, err = computeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) + _, err = helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) if err != nil { panic(err) } b.ResetTimer() for n := 0; n < b.N; n++ { - _, err := computeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) + _, err := helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) if err != nil { panic(err) } @@ -549,9 +550,9 @@ func BenchmarkComputeCommittee128000_WithOutPreCache(b *testing.B) { require.NoError(b, err) epoch := time.CurrentEpoch(state) - indices, err := ActiveValidatorIndices(context.Background(), state, epoch) + indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch) require.NoError(b, err) - seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) + seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) require.NoError(b, err) i := uint64(0) @@ -559,7 +560,7 @@ func BenchmarkComputeCommittee128000_WithOutPreCache(b *testing.B) { b.ResetTimer() for n := 0; n < b.N; n++ { i++ - _, err := computeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) + _, err := helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) if err != nil { panic(err) } @@ -584,9 +585,9 @@ func BenchmarkComputeCommittee1000000_WithOutCache(b *testing.B) { require.NoError(b, err) epoch := time.CurrentEpoch(state) - indices, err := ActiveValidatorIndices(context.Background(), state, epoch) + indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch) require.NoError(b, err) - seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) + seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) require.NoError(b, err) i := uint64(0) @@ -594,7 +595,7 @@ func BenchmarkComputeCommittee1000000_WithOutCache(b *testing.B) { b.ResetTimer() for n := 0; n < b.N; n++ { i++ - _, err := computeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) + _, err := helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) if err != nil { panic(err) } @@ -619,9 +620,9 @@ func BenchmarkComputeCommittee4000000_WithOutCache(b *testing.B) { require.NoError(b, err) epoch := time.CurrentEpoch(state) - indices, err := ActiveValidatorIndices(context.Background(), state, epoch) + indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch) require.NoError(b, err) - seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) + seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester) require.NoError(b, err) i := uint64(0) @@ -629,7 +630,7 @@ func BenchmarkComputeCommittee4000000_WithOutCache(b *testing.B) { b.ResetTimer() for n := 0; n < b.N; n++ { i++ - _, err := computeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) + _, err := helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot) if err != nil { panic(err) } @@ -655,13 +656,13 @@ func TestBeaconCommitteeFromState_UpdateCacheForPreviousEpoch(t *testing.T) { RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector), }) require.NoError(t, err) - _, err = BeaconCommitteeFromState(context.Background(), state, 1 /* previous epoch */, 0) + _, err = helpers.BeaconCommitteeFromState(context.Background(), state, 1 /* previous epoch */, 0) require.NoError(t, err) // Verify previous epoch is cached - seed, err := Seed(state, 0, params.BeaconConfig().DomainBeaconAttester) + seed, err := helpers.Seed(state, 0, params.BeaconConfig().DomainBeaconAttester) require.NoError(t, err) - activeIndices, err := committeeCache.ActiveIndices(context.Background(), seed) + activeIndices, err := helpers.CommitteeCache().ActiveIndices(context.Background(), seed) require.NoError(t, err) assert.NotNil(t, activeIndices, "Did not cache active indices") } @@ -680,19 +681,19 @@ func TestPrecomputeProposerIndices_Ok(t *testing.T) { }) require.NoError(t, err) - indices, err := ActiveValidatorIndices(context.Background(), state, 0) + indices, err := helpers.ActiveValidatorIndices(context.Background(), state, 0) require.NoError(t, err) - proposerIndices, err := precomputeProposerIndices(state, indices, time.CurrentEpoch(state)) + proposerIndices, err := helpers.PrecomputeProposerIndices(state, indices, time.CurrentEpoch(state)) require.NoError(t, err) var wantedProposerIndices []primitives.ValidatorIndex - seed, err := Seed(state, 0, params.BeaconConfig().DomainBeaconProposer) + seed, err := helpers.Seed(state, 0, params.BeaconConfig().DomainBeaconProposer) require.NoError(t, err) for i := uint64(0); i < uint64(params.BeaconConfig().SlotsPerEpoch); i++ { seedWithSlot := append(seed[:], bytesutil.Bytes8(i)...) seedWithSlotHash := hash.Hash(seedWithSlot) - index, err := ComputeProposerIndex(state, indices, seedWithSlotHash) + index, err := helpers.ComputeProposerIndex(state, indices, seedWithSlotHash) require.NoError(t, err) wantedProposerIndices = append(wantedProposerIndices, index) } diff --git a/beacon-chain/core/helpers/private_access_fuzz_noop_test.go b/beacon-chain/core/helpers/private_access_fuzz_noop_test.go new file mode 100644 index 0000000000..c17f1e6c93 --- /dev/null +++ b/beacon-chain/core/helpers/private_access_fuzz_noop_test.go @@ -0,0 +1,17 @@ +//go:build fuzz + +package helpers + +import "github.com/prysmaticlabs/prysm/v5/beacon-chain/cache" + +func CommitteeCache() *cache.FakeCommitteeCache { + return committeeCache +} + +func SyncCommitteeCache() *cache.FakeSyncCommitteeCache { + return syncCommitteeCache +} + +func ProposerIndicesCache() *cache.FakeProposerIndicesCache { + return proposerIndicesCache +} diff --git a/beacon-chain/core/helpers/private_access_test.go b/beacon-chain/core/helpers/private_access_test.go new file mode 100644 index 0000000000..1a3a984d0e --- /dev/null +++ b/beacon-chain/core/helpers/private_access_test.go @@ -0,0 +1,17 @@ +//go:build !fuzz + +package helpers + +import "github.com/prysmaticlabs/prysm/v5/beacon-chain/cache" + +func CommitteeCache() *cache.CommitteeCache { + return committeeCache +} + +func SyncCommitteeCache() *cache.SyncCommitteeCache { + return syncCommitteeCache +} + +func ProposerIndicesCache() *cache.ProposerIndicesCache { + return proposerIndicesCache +} diff --git a/beacon-chain/core/helpers/randao_test.go b/beacon-chain/core/helpers/randao_test.go index 2246d7abb0..551331fdc0 100644 --- a/beacon-chain/core/helpers/randao_test.go +++ b/beacon-chain/core/helpers/randao_test.go @@ -1,9 +1,10 @@ -package helpers +package helpers_test import ( "encoding/binary" "testing" + "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers" state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native" "github.com/prysmaticlabs/prysm/v5/config/params" "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives" @@ -40,10 +41,10 @@ func TestRandaoMix_OK(t *testing.T) { }, } for _, test := range tests { - ClearCache() + helpers.ClearCache() require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch.Mul(uint64(test.epoch+1)))) - mix, err := RandaoMix(state, test.epoch) + mix, err := helpers.RandaoMix(state, test.epoch) require.NoError(t, err) assert.DeepEqual(t, test.randaoMix, mix, "Incorrect randao mix") } @@ -76,10 +77,10 @@ func TestRandaoMix_CopyOK(t *testing.T) { }, } for _, test := range tests { - ClearCache() + helpers.ClearCache() require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch.Mul(uint64(test.epoch+1)))) - mix, err := RandaoMix(state, test.epoch) + mix, err := helpers.RandaoMix(state, test.epoch) require.NoError(t, err) uniqueNumber := uint64(params.BeaconConfig().EpochsPerHistoricalVector.Add(1000)) binary.LittleEndian.PutUint64(mix, uniqueNumber) @@ -92,7 +93,7 @@ func TestRandaoMix_CopyOK(t *testing.T) { } func TestGenerateSeed_OK(t *testing.T) { - ClearCache() + helpers.ClearCache() randaoMixes := make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector) for i := 0; i < len(randaoMixes); i++ { @@ -107,7 +108,7 @@ func TestGenerateSeed_OK(t *testing.T) { }) require.NoError(t, err) - got, err := Seed(state, 10, params.BeaconConfig().DomainBeaconAttester) + got, err := helpers.Seed(state, 10, params.BeaconConfig().DomainBeaconAttester) require.NoError(t, err) wanted := [32]byte{102, 82, 23, 40, 226, 79, 171, 11, 203, 23, 175, 7, 88, 202, 80, diff --git a/beacon-chain/core/helpers/rewards_penalties_test.go b/beacon-chain/core/helpers/rewards_penalties_test.go index 4aeeeb7394..e9cd2807ea 100644 --- a/beacon-chain/core/helpers/rewards_penalties_test.go +++ b/beacon-chain/core/helpers/rewards_penalties_test.go @@ -1,9 +1,10 @@ -package helpers +package helpers_test import ( "math" "testing" + "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers" "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time" state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native" "github.com/prysmaticlabs/prysm/v5/config/params" @@ -14,7 +15,7 @@ import ( ) func TestTotalBalance_OK(t *testing.T) { - ClearCache() + helpers.ClearCache() state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{Validators: []*ethpb.Validator{ {EffectiveBalance: 27 * 1e9}, {EffectiveBalance: 28 * 1e9}, @@ -22,19 +23,19 @@ func TestTotalBalance_OK(t *testing.T) { }}) require.NoError(t, err) - balance := TotalBalance(state, []primitives.ValidatorIndex{0, 1, 2, 3}) + balance := helpers.TotalBalance(state, []primitives.ValidatorIndex{0, 1, 2, 3}) wanted := state.Validators()[0].EffectiveBalance + state.Validators()[1].EffectiveBalance + state.Validators()[2].EffectiveBalance + state.Validators()[3].EffectiveBalance assert.Equal(t, wanted, balance, "Incorrect TotalBalance") } func TestTotalBalance_ReturnsEffectiveBalanceIncrement(t *testing.T) { - ClearCache() + helpers.ClearCache() state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{Validators: []*ethpb.Validator{}}) require.NoError(t, err) - balance := TotalBalance(state, []primitives.ValidatorIndex{}) + balance := helpers.TotalBalance(state, []primitives.ValidatorIndex{}) wanted := params.BeaconConfig().EffectiveBalanceIncrement assert.Equal(t, wanted, balance, "Incorrect TotalBalance") } @@ -51,7 +52,7 @@ func TestGetBalance_OK(t *testing.T) { {i: 2, b: []uint64{0, 0, 0}}, } for _, test := range tests { - ClearCache() + helpers.ClearCache() state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{Balances: test.b}) require.NoError(t, err) @@ -68,7 +69,7 @@ func TestTotalActiveBalance(t *testing.T) { {10000}, } for _, test := range tests { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, 0) for i := 0; i < test.vCount; i++ { @@ -76,7 +77,7 @@ func TestTotalActiveBalance(t *testing.T) { } state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{Validators: validators}) require.NoError(t, err) - bal, err := TotalActiveBalance(state) + bal, err := helpers.TotalActiveBalance(state) require.NoError(t, err) require.Equal(t, uint64(test.vCount)*params.BeaconConfig().MaxEffectiveBalance, bal) } @@ -91,7 +92,7 @@ func TestTotalActiveBal_ReturnMin(t *testing.T) { {10000}, } for _, test := range tests { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, 0) for i := 0; i < test.vCount; i++ { @@ -99,7 +100,7 @@ func TestTotalActiveBal_ReturnMin(t *testing.T) { } state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{Validators: validators}) require.NoError(t, err) - bal, err := TotalActiveBalance(state) + bal, err := helpers.TotalActiveBalance(state) require.NoError(t, err) require.Equal(t, params.BeaconConfig().EffectiveBalanceIncrement, bal) } @@ -115,7 +116,7 @@ func TestTotalActiveBalance_WithCache(t *testing.T) { {vCount: 10000, wantCount: 10000}, } for _, test := range tests { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, 0) for i := 0; i < test.vCount; i++ { @@ -123,7 +124,7 @@ func TestTotalActiveBalance_WithCache(t *testing.T) { } state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{Validators: validators}) require.NoError(t, err) - bal, err := TotalActiveBalance(state) + bal, err := helpers.TotalActiveBalance(state) require.NoError(t, err) require.Equal(t, uint64(test.wantCount)*params.BeaconConfig().MaxEffectiveBalance, bal) } @@ -141,7 +142,7 @@ func TestIncreaseBalance_OK(t *testing.T) { {i: 2, b: []uint64{27 * 1e9, 28 * 1e9, 32 * 1e9}, nb: 33 * 1e9, eb: 65 * 1e9}, } for _, test := range tests { - ClearCache() + helpers.ClearCache() state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{ Validators: []*ethpb.Validator{ @@ -149,7 +150,7 @@ func TestIncreaseBalance_OK(t *testing.T) { Balances: test.b, }) require.NoError(t, err) - require.NoError(t, IncreaseBalance(state, test.i, test.nb)) + require.NoError(t, helpers.IncreaseBalance(state, test.i, test.nb)) assert.Equal(t, test.eb, state.Balances()[test.i], "Incorrect Validator balance") } } @@ -167,7 +168,7 @@ func TestDecreaseBalance_OK(t *testing.T) { {i: 3, b: []uint64{27 * 1e9, 28 * 1e9, 1, 28 * 1e9}, nb: 28 * 1e9, eb: 0}, } for _, test := range tests { - ClearCache() + helpers.ClearCache() state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{ Validators: []*ethpb.Validator{ @@ -175,13 +176,13 @@ func TestDecreaseBalance_OK(t *testing.T) { Balances: test.b, }) require.NoError(t, err) - require.NoError(t, DecreaseBalance(state, test.i, test.nb)) + require.NoError(t, helpers.DecreaseBalance(state, test.i, test.nb)) assert.Equal(t, test.eb, state.Balances()[test.i], "Incorrect Validator balance") } } func TestFinalityDelay(t *testing.T) { - ClearCache() + helpers.ClearCache() base := buildState(params.BeaconConfig().SlotsPerEpoch*10, 1) base.FinalizedCheckpoint = ðpb.Checkpoint{Epoch: 3} @@ -195,25 +196,25 @@ func TestFinalityDelay(t *testing.T) { finalizedEpoch = beaconState.FinalizedCheckpointEpoch() } setVal() - d := FinalityDelay(prevEpoch, finalizedEpoch) + d := helpers.FinalityDelay(prevEpoch, finalizedEpoch) w := time.PrevEpoch(beaconState) - beaconState.FinalizedCheckpointEpoch() assert.Equal(t, w, d, "Did not get wanted finality delay") require.NoError(t, beaconState.SetFinalizedCheckpoint(ðpb.Checkpoint{Epoch: 4})) setVal() - d = FinalityDelay(prevEpoch, finalizedEpoch) + d = helpers.FinalityDelay(prevEpoch, finalizedEpoch) w = time.PrevEpoch(beaconState) - beaconState.FinalizedCheckpointEpoch() assert.Equal(t, w, d, "Did not get wanted finality delay") require.NoError(t, beaconState.SetFinalizedCheckpoint(ðpb.Checkpoint{Epoch: 5})) setVal() - d = FinalityDelay(prevEpoch, finalizedEpoch) + d = helpers.FinalityDelay(prevEpoch, finalizedEpoch) w = time.PrevEpoch(beaconState) - beaconState.FinalizedCheckpointEpoch() assert.Equal(t, w, d, "Did not get wanted finality delay") } func TestIsInInactivityLeak(t *testing.T) { - ClearCache() + helpers.ClearCache() base := buildState(params.BeaconConfig().SlotsPerEpoch*10, 1) base.FinalizedCheckpoint = ðpb.Checkpoint{Epoch: 3} @@ -227,13 +228,13 @@ func TestIsInInactivityLeak(t *testing.T) { finalizedEpoch = beaconState.FinalizedCheckpointEpoch() } setVal() - assert.Equal(t, true, IsInInactivityLeak(prevEpoch, finalizedEpoch), "Wanted inactivity leak true") + assert.Equal(t, true, helpers.IsInInactivityLeak(prevEpoch, finalizedEpoch), "Wanted inactivity leak true") require.NoError(t, beaconState.SetFinalizedCheckpoint(ðpb.Checkpoint{Epoch: 4})) setVal() - assert.Equal(t, true, IsInInactivityLeak(prevEpoch, finalizedEpoch), "Wanted inactivity leak true") + assert.Equal(t, true, helpers.IsInInactivityLeak(prevEpoch, finalizedEpoch), "Wanted inactivity leak true") require.NoError(t, beaconState.SetFinalizedCheckpoint(ðpb.Checkpoint{Epoch: 5})) setVal() - assert.Equal(t, false, IsInInactivityLeak(prevEpoch, finalizedEpoch), "Wanted inactivity leak false") + assert.Equal(t, false, helpers.IsInInactivityLeak(prevEpoch, finalizedEpoch), "Wanted inactivity leak false") } func buildState(slot primitives.Slot, validatorCount uint64) *ethpb.BeaconState { @@ -285,7 +286,7 @@ func TestIncreaseBadBalance_NotOK(t *testing.T) { {i: 2, b: []uint64{math.MaxUint64, math.MaxUint64, math.MaxUint64}, nb: 33 * 1e9}, } for _, test := range tests { - ClearCache() + helpers.ClearCache() state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{ Validators: []*ethpb.Validator{ @@ -293,6 +294,6 @@ func TestIncreaseBadBalance_NotOK(t *testing.T) { Balances: test.b, }) require.NoError(t, err) - require.ErrorContains(t, "addition overflows", IncreaseBalance(state, test.i, test.nb)) + require.ErrorContains(t, "addition overflows", helpers.IncreaseBalance(state, test.i, test.nb)) } } diff --git a/beacon-chain/core/helpers/sync_committee.go b/beacon-chain/core/helpers/sync_committee.go index 87e5a82af0..8c93094582 100644 --- a/beacon-chain/core/helpers/sync_committee.go +++ b/beacon-chain/core/helpers/sync_committee.go @@ -26,7 +26,7 @@ var ( // 1. Checks if the public key exists in the sync committee cache // 2. If 1 fails, checks if the public key exists in the input current sync committee object func IsCurrentPeriodSyncCommittee(st state.BeaconState, valIdx primitives.ValidatorIndex) (bool, error) { - root, err := syncPeriodBoundaryRoot(st) + root, err := SyncPeriodBoundaryRoot(st) if err != nil { return false, err } @@ -63,7 +63,7 @@ func IsCurrentPeriodSyncCommittee(st state.BeaconState, valIdx primitives.Valida func IsNextPeriodSyncCommittee( st state.BeaconState, valIdx primitives.ValidatorIndex, ) (bool, error) { - root, err := syncPeriodBoundaryRoot(st) + root, err := SyncPeriodBoundaryRoot(st) if err != nil { return false, err } @@ -90,7 +90,7 @@ func IsNextPeriodSyncCommittee( func CurrentPeriodSyncSubcommitteeIndices( st state.BeaconState, valIdx primitives.ValidatorIndex, ) ([]primitives.CommitteeIndex, error) { - root, err := syncPeriodBoundaryRoot(st) + root, err := SyncPeriodBoundaryRoot(st) if err != nil { return nil, err } @@ -124,7 +124,7 @@ func CurrentPeriodSyncSubcommitteeIndices( func NextPeriodSyncSubcommitteeIndices( st state.BeaconState, valIdx primitives.ValidatorIndex, ) ([]primitives.CommitteeIndex, error) { - root, err := syncPeriodBoundaryRoot(st) + root, err := SyncPeriodBoundaryRoot(st) if err != nil { return nil, err } @@ -182,10 +182,10 @@ func findSubCommitteeIndices(pubKey []byte, pubKeys [][]byte) []primitives.Commi return indices } -// Retrieve the current sync period boundary root by calculating sync period start epoch +// SyncPeriodBoundaryRoot computes the current sync period boundary root by calculating sync period start epoch // and calling `BlockRoot`. // It uses the boundary slot - 1 for block root. (Ex: SlotsPerEpoch * EpochsPerSyncCommitteePeriod - 1) -func syncPeriodBoundaryRoot(st state.ReadOnlyBeaconState) ([32]byte, error) { +func SyncPeriodBoundaryRoot(st state.ReadOnlyBeaconState) ([32]byte, error) { // Can't call `BlockRoot` until the first slot. if st.Slot() == params.BeaconConfig().GenesisSlot { return params.BeaconConfig().ZeroHash, nil diff --git a/beacon-chain/core/helpers/sync_committee_test.go b/beacon-chain/core/helpers/sync_committee_test.go index f321e57862..6061294772 100644 --- a/beacon-chain/core/helpers/sync_committee_test.go +++ b/beacon-chain/core/helpers/sync_committee_test.go @@ -1,4 +1,4 @@ -package helpers +package helpers_test import ( "math/rand" @@ -7,6 +7,7 @@ import ( "time" "github.com/prysmaticlabs/prysm/v5/beacon-chain/cache" + "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers" state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native" "github.com/prysmaticlabs/prysm/v5/config/params" "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives" @@ -17,7 +18,7 @@ import ( ) func TestIsCurrentEpochSyncCommittee_UsingCache(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -40,15 +41,15 @@ func TestIsCurrentEpochSyncCommittee_UsingCache(t *testing.T) { require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) r := [32]byte{'a'} - require.NoError(t, err, syncCommitteeCache.UpdatePositionsInCommittee(r, state)) + require.NoError(t, err, helpers.SyncCommitteeCache().UpdatePositionsInCommittee(r, state)) - ok, err := IsCurrentPeriodSyncCommittee(state, 0) + ok, err := helpers.IsCurrentPeriodSyncCommittee(state, 0) require.NoError(t, err) require.Equal(t, true, ok) } func TestIsCurrentEpochSyncCommittee_UsingCommittee(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -70,13 +71,13 @@ func TestIsCurrentEpochSyncCommittee_UsingCommittee(t *testing.T) { require.NoError(t, state.SetCurrentSyncCommittee(syncCommittee)) require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) - ok, err := IsCurrentPeriodSyncCommittee(state, 0) + ok, err := helpers.IsCurrentPeriodSyncCommittee(state, 0) require.NoError(t, err) require.Equal(t, true, ok) } func TestIsCurrentEpochSyncCommittee_DoesNotExist(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -98,13 +99,13 @@ func TestIsCurrentEpochSyncCommittee_DoesNotExist(t *testing.T) { require.NoError(t, state.SetCurrentSyncCommittee(syncCommittee)) require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) - ok, err := IsCurrentPeriodSyncCommittee(state, 12390192) + ok, err := helpers.IsCurrentPeriodSyncCommittee(state, 12390192) require.ErrorContains(t, "validator index 12390192 does not exist", err) require.Equal(t, false, ok) } func TestIsNextEpochSyncCommittee_UsingCache(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -127,15 +128,15 @@ func TestIsNextEpochSyncCommittee_UsingCache(t *testing.T) { require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) r := [32]byte{'a'} - require.NoError(t, err, syncCommitteeCache.UpdatePositionsInCommittee(r, state)) + require.NoError(t, err, helpers.SyncCommitteeCache().UpdatePositionsInCommittee(r, state)) - ok, err := IsNextPeriodSyncCommittee(state, 0) + ok, err := helpers.IsNextPeriodSyncCommittee(state, 0) require.NoError(t, err) require.Equal(t, true, ok) } func TestIsNextEpochSyncCommittee_UsingCommittee(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -157,13 +158,13 @@ func TestIsNextEpochSyncCommittee_UsingCommittee(t *testing.T) { require.NoError(t, state.SetCurrentSyncCommittee(syncCommittee)) require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) - ok, err := IsNextPeriodSyncCommittee(state, 0) + ok, err := helpers.IsNextPeriodSyncCommittee(state, 0) require.NoError(t, err) require.Equal(t, true, ok) } func TestIsNextEpochSyncCommittee_DoesNotExist(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -185,13 +186,13 @@ func TestIsNextEpochSyncCommittee_DoesNotExist(t *testing.T) { require.NoError(t, state.SetCurrentSyncCommittee(syncCommittee)) require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) - ok, err := IsNextPeriodSyncCommittee(state, 120391029) + ok, err := helpers.IsNextPeriodSyncCommittee(state, 120391029) require.ErrorContains(t, "validator index 120391029 does not exist", err) require.Equal(t, false, ok) } func TestCurrentEpochSyncSubcommitteeIndices_UsingCache(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -214,15 +215,15 @@ func TestCurrentEpochSyncSubcommitteeIndices_UsingCache(t *testing.T) { require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) r := [32]byte{'a'} - require.NoError(t, err, syncCommitteeCache.UpdatePositionsInCommittee(r, state)) + require.NoError(t, err, helpers.SyncCommitteeCache().UpdatePositionsInCommittee(r, state)) - index, err := CurrentPeriodSyncSubcommitteeIndices(state, 0) + index, err := helpers.CurrentPeriodSyncSubcommitteeIndices(state, 0) require.NoError(t, err) require.DeepEqual(t, []primitives.CommitteeIndex{0}, index) } func TestCurrentEpochSyncSubcommitteeIndices_UsingCommittee(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -243,27 +244,27 @@ func TestCurrentEpochSyncSubcommitteeIndices_UsingCommittee(t *testing.T) { require.NoError(t, err) require.NoError(t, state.SetCurrentSyncCommittee(syncCommittee)) require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) - root, err := syncPeriodBoundaryRoot(state) + root, err := helpers.SyncPeriodBoundaryRoot(state) require.NoError(t, err) // Test that cache was empty. - _, err = syncCommitteeCache.CurrentPeriodIndexPosition(root, 0) + _, err = helpers.SyncCommitteeCache().CurrentPeriodIndexPosition(root, 0) require.Equal(t, cache.ErrNonExistingSyncCommitteeKey, err) // Test that helper can retrieve the index given empty cache. - index, err := CurrentPeriodSyncSubcommitteeIndices(state, 0) + index, err := helpers.CurrentPeriodSyncSubcommitteeIndices(state, 0) require.NoError(t, err) require.DeepEqual(t, []primitives.CommitteeIndex{0}, index) // Test that cache was able to fill on miss. time.Sleep(100 * time.Millisecond) - index, err = syncCommitteeCache.CurrentPeriodIndexPosition(root, 0) + index, err = helpers.SyncCommitteeCache().CurrentPeriodIndexPosition(root, 0) require.NoError(t, err) require.DeepEqual(t, []primitives.CommitteeIndex{0}, index) } func TestCurrentEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -285,13 +286,13 @@ func TestCurrentEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) { require.NoError(t, state.SetCurrentSyncCommittee(syncCommittee)) require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) - index, err := CurrentPeriodSyncSubcommitteeIndices(state, 129301923) + index, err := helpers.CurrentPeriodSyncSubcommitteeIndices(state, 129301923) require.ErrorContains(t, "validator index 129301923 does not exist", err) require.DeepEqual(t, []primitives.CommitteeIndex(nil), index) } func TestNextEpochSyncSubcommitteeIndices_UsingCache(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -314,15 +315,15 @@ func TestNextEpochSyncSubcommitteeIndices_UsingCache(t *testing.T) { require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) r := [32]byte{'a'} - require.NoError(t, err, syncCommitteeCache.UpdatePositionsInCommittee(r, state)) + require.NoError(t, err, helpers.SyncCommitteeCache().UpdatePositionsInCommittee(r, state)) - index, err := NextPeriodSyncSubcommitteeIndices(state, 0) + index, err := helpers.NextPeriodSyncSubcommitteeIndices(state, 0) require.NoError(t, err) require.DeepEqual(t, []primitives.CommitteeIndex{0}, index) } func TestNextEpochSyncSubcommitteeIndices_UsingCommittee(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -344,13 +345,13 @@ func TestNextEpochSyncSubcommitteeIndices_UsingCommittee(t *testing.T) { require.NoError(t, state.SetCurrentSyncCommittee(syncCommittee)) require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) - index, err := NextPeriodSyncSubcommitteeIndices(state, 0) + index, err := helpers.NextPeriodSyncSubcommitteeIndices(state, 0) require.NoError(t, err) require.DeepEqual(t, []primitives.CommitteeIndex{0}, index) } func TestNextEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -372,43 +373,43 @@ func TestNextEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) { require.NoError(t, state.SetCurrentSyncCommittee(syncCommittee)) require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) - index, err := NextPeriodSyncSubcommitteeIndices(state, 21093019) + index, err := helpers.NextPeriodSyncSubcommitteeIndices(state, 21093019) require.ErrorContains(t, "validator index 21093019 does not exist", err) require.DeepEqual(t, []primitives.CommitteeIndex(nil), index) } func TestUpdateSyncCommitteeCache_BadSlot(t *testing.T) { - ClearCache() + helpers.ClearCache() state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{ Slot: 1, }) require.NoError(t, err) - err = UpdateSyncCommitteeCache(state) + err = helpers.UpdateSyncCommitteeCache(state) require.ErrorContains(t, "not at the end of the epoch to update cache", err) state, err = state_native.InitializeFromProtoPhase0(ðpb.BeaconState{ Slot: params.BeaconConfig().SlotsPerEpoch - 1, }) require.NoError(t, err) - err = UpdateSyncCommitteeCache(state) + err = helpers.UpdateSyncCommitteeCache(state) require.ErrorContains(t, "not at sync committee period boundary to update cache", err) } func TestUpdateSyncCommitteeCache_BadRoot(t *testing.T) { - ClearCache() + helpers.ClearCache() state, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{ Slot: primitives.Slot(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*params.BeaconConfig().SlotsPerEpoch - 1, LatestBlockHeader: ðpb.BeaconBlockHeader{StateRoot: params.BeaconConfig().ZeroHash[:]}, }) require.NoError(t, err) - err = UpdateSyncCommitteeCache(state) + err = helpers.UpdateSyncCommitteeCache(state) require.ErrorContains(t, "zero hash state root can't be used to update cache", err) } func TestIsCurrentEpochSyncCommittee_SameBlockRoot(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize) syncCommittee := ðpb.SyncCommittee{ @@ -435,7 +436,7 @@ func TestIsCurrentEpochSyncCommittee_SameBlockRoot(t *testing.T) { require.NoError(t, state.SetCurrentSyncCommittee(syncCommittee)) require.NoError(t, state.SetNextSyncCommittee(syncCommittee)) - comIdxs, err := CurrentPeriodSyncSubcommitteeIndices(state, 200) + comIdxs, err := helpers.CurrentPeriodSyncSubcommitteeIndices(state, 200) require.NoError(t, err) wantedSlot := params.BeaconConfig().EpochsPerSyncCommitteePeriod.Mul(uint64(params.BeaconConfig().SlotsPerEpoch)) @@ -446,7 +447,7 @@ func TestIsCurrentEpochSyncCommittee_SameBlockRoot(t *testing.T) { syncCommittee.Pubkeys[i], syncCommittee.Pubkeys[j] = syncCommittee.Pubkeys[j], syncCommittee.Pubkeys[i] }) require.NoError(t, state.SetCurrentSyncCommittee(syncCommittee)) - newIdxs, err := CurrentPeriodSyncSubcommitteeIndices(state, 200) + newIdxs, err := helpers.CurrentPeriodSyncSubcommitteeIndices(state, 200) require.NoError(t, err) require.DeepNotEqual(t, comIdxs, newIdxs) } diff --git a/beacon-chain/core/helpers/validators_test.go b/beacon-chain/core/helpers/validators_test.go index 54a13ffbaf..0471e1740d 100644 --- a/beacon-chain/core/helpers/validators_test.go +++ b/beacon-chain/core/helpers/validators_test.go @@ -1,4 +1,4 @@ -package helpers +package helpers_test import ( "context" @@ -6,6 +6,7 @@ import ( "testing" "github.com/prysmaticlabs/prysm/v5/beacon-chain/cache" + "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers" "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time" forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types" state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native" @@ -32,7 +33,7 @@ func TestIsActiveValidator_OK(t *testing.T) { } for _, test := range tests { validator := ðpb.Validator{ActivationEpoch: 10, ExitEpoch: 100} - assert.Equal(t, test.b, IsActiveValidator(validator, test.a), "IsActiveValidator(%d)", test.a) + assert.Equal(t, test.b, helpers.IsActiveValidator(validator, test.a), "IsActiveValidator(%d)", test.a) } } @@ -53,7 +54,7 @@ func TestIsActiveValidatorUsingTrie_OK(t *testing.T) { for _, test := range tests { readOnlyVal, err := beaconState.ValidatorAtIndexReadOnly(0) require.NoError(t, err) - assert.Equal(t, test.b, IsActiveValidatorUsingTrie(readOnlyVal, test.a), "IsActiveValidatorUsingTrie(%d)", test.a) + assert.Equal(t, test.b, helpers.IsActiveValidatorUsingTrie(readOnlyVal, test.a), "IsActiveValidatorUsingTrie(%d)", test.a) } } @@ -81,7 +82,7 @@ func TestIsActiveNonSlashedValidatorUsingTrie_OK(t *testing.T) { require.NoError(t, err) readOnlyVal, err := beaconState.ValidatorAtIndexReadOnly(0) require.NoError(t, err) - assert.Equal(t, test.b, IsActiveNonSlashedValidatorUsingTrie(readOnlyVal, test.a), "IsActiveNonSlashedValidatorUsingTrie(%d)", test.a) + assert.Equal(t, test.b, helpers.IsActiveNonSlashedValidatorUsingTrie(readOnlyVal, test.a), "IsActiveNonSlashedValidatorUsingTrie(%d)", test.a) } } @@ -161,7 +162,7 @@ func TestIsSlashableValidator_OK(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { t.Run("without trie", func(t *testing.T) { - slashableValidator := IsSlashableValidator(test.validator.ActivationEpoch, + slashableValidator := helpers.IsSlashableValidator(test.validator.ActivationEpoch, test.validator.WithdrawableEpoch, test.validator.Slashed, test.epoch) assert.Equal(t, test.slashable, slashableValidator, "Expected active validator slashable to be %t", test.slashable) }) @@ -170,7 +171,7 @@ func TestIsSlashableValidator_OK(t *testing.T) { require.NoError(t, err) readOnlyVal, err := beaconState.ValidatorAtIndexReadOnly(0) require.NoError(t, err) - slashableValidator := IsSlashableValidatorUsingTrie(readOnlyVal, test.epoch) + slashableValidator := helpers.IsSlashableValidatorUsingTrie(readOnlyVal, test.epoch) assert.Equal(t, test.slashable, slashableValidator, "Expected active validator slashable to be %t", test.slashable) }) }) @@ -223,17 +224,17 @@ func TestBeaconProposerIndex_OK(t *testing.T) { } for _, tt := range tests { - ClearCache() + helpers.ClearCache() require.NoError(t, state.SetSlot(tt.slot)) - result, err := BeaconProposerIndex(context.Background(), state) + result, err := helpers.BeaconProposerIndex(context.Background(), state) require.NoError(t, err, "Failed to get shard and committees at slot") assert.Equal(t, tt.index, result, "Result index was an unexpected value") } } func TestBeaconProposerIndex_BadState(t *testing.T) { - ClearCache() + helpers.ClearCache() params.SetupTestConfigCleanup(t) c := params.BeaconConfig() @@ -261,12 +262,12 @@ func TestBeaconProposerIndex_BadState(t *testing.T) { // Set a very high slot, so that retrieved block root will be // non existent for the proposer cache. require.NoError(t, state.SetSlot(100)) - _, err = BeaconProposerIndex(context.Background(), state) + _, err = helpers.BeaconProposerIndex(context.Background(), state) require.NoError(t, err) } func TestComputeProposerIndex_Compatibility(t *testing.T) { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount) for i := 0; i < len(validators); i++ { @@ -281,22 +282,22 @@ func TestComputeProposerIndex_Compatibility(t *testing.T) { }) require.NoError(t, err) - indices, err := ActiveValidatorIndices(context.Background(), state, 0) + indices, err := helpers.ActiveValidatorIndices(context.Background(), state, 0) require.NoError(t, err) var proposerIndices []primitives.ValidatorIndex - seed, err := Seed(state, 0, params.BeaconConfig().DomainBeaconProposer) + seed, err := helpers.Seed(state, 0, params.BeaconConfig().DomainBeaconProposer) require.NoError(t, err) for i := uint64(0); i < uint64(params.BeaconConfig().SlotsPerEpoch); i++ { seedWithSlot := append(seed[:], bytesutil.Bytes8(i)...) seedWithSlotHash := hash.Hash(seedWithSlot) - index, err := ComputeProposerIndex(state, indices, seedWithSlotHash) + index, err := helpers.ComputeProposerIndex(state, indices, seedWithSlotHash) require.NoError(t, err) proposerIndices = append(proposerIndices, index) } var wantedProposerIndices []primitives.ValidatorIndex - seed, err = Seed(state, 0, params.BeaconConfig().DomainBeaconProposer) + seed, err = helpers.Seed(state, 0, params.BeaconConfig().DomainBeaconProposer) require.NoError(t, err) for i := uint64(0); i < uint64(params.BeaconConfig().SlotsPerEpoch); i++ { seedWithSlot := append(seed[:], bytesutil.Bytes8(i)...) @@ -309,15 +310,15 @@ func TestComputeProposerIndex_Compatibility(t *testing.T) { } func TestDelayedActivationExitEpoch_OK(t *testing.T) { - ClearCache() + helpers.ClearCache() epoch := primitives.Epoch(9999) wanted := epoch + 1 + params.BeaconConfig().MaxSeedLookahead - assert.Equal(t, wanted, ActivationExitEpoch(epoch)) + assert.Equal(t, wanted, helpers.ActivationExitEpoch(epoch)) } func TestActiveValidatorCount_Genesis(t *testing.T) { - ClearCache() + helpers.ClearCache() c := 1000 validators := make([]*ethpb.Validator, c) @@ -334,10 +335,10 @@ func TestActiveValidatorCount_Genesis(t *testing.T) { require.NoError(t, err) // Preset cache to a bad count. - seed, err := Seed(beaconState, 0, params.BeaconConfig().DomainBeaconAttester) + seed, err := helpers.Seed(beaconState, 0, params.BeaconConfig().DomainBeaconAttester) require.NoError(t, err) - require.NoError(t, committeeCache.AddCommitteeShuffledList(context.Background(), &cache.Committees{Seed: seed, ShuffledIndices: []primitives.ValidatorIndex{1, 2, 3}})) - validatorCount, err := ActiveValidatorCount(context.Background(), beaconState, time.CurrentEpoch(beaconState)) + require.NoError(t, helpers.CommitteeCache().AddCommitteeShuffledList(context.Background(), &cache.Committees{Seed: seed, ShuffledIndices: []primitives.ValidatorIndex{1, 2, 3}})) + validatorCount, err := helpers.ActiveValidatorCount(context.Background(), beaconState, time.CurrentEpoch(beaconState)) require.NoError(t, err) assert.Equal(t, uint64(c), validatorCount, "Did not get the correct validator count") } @@ -353,7 +354,7 @@ func TestChurnLimit_OK(t *testing.T) { {validatorCount: 2000000, wantedChurn: 30 /* validatorCount/churnLimitQuotient */}, } for _, test := range tests { - ClearCache() + helpers.ClearCache() validators := make([]*ethpb.Validator, test.validatorCount) for i := 0; i < len(validators); i++ { @@ -368,9 +369,9 @@ func TestChurnLimit_OK(t *testing.T) { RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector), }) require.NoError(t, err) - validatorCount, err := ActiveValidatorCount(context.Background(), beaconState, time.CurrentEpoch(beaconState)) + validatorCount, err := helpers.ActiveValidatorCount(context.Background(), beaconState, time.CurrentEpoch(beaconState)) require.NoError(t, err) - resultChurn := ValidatorActivationChurnLimit(validatorCount) + resultChurn := helpers.ValidatorActivationChurnLimit(validatorCount) assert.Equal(t, test.wantedChurn, resultChurn, "ValidatorActivationChurnLimit(%d)", test.validatorCount) } } @@ -386,7 +387,7 @@ func TestChurnLimitDeneb_OK(t *testing.T) { {2000000, params.BeaconConfig().MaxPerEpochActivationChurnLimit}, } for _, test := range tests { - ClearCache() + helpers.ClearCache() // Create validators validators := make([]*ethpb.Validator, test.validatorCount) @@ -405,11 +406,11 @@ func TestChurnLimitDeneb_OK(t *testing.T) { require.NoError(t, err) // Get active validator count - validatorCount, err := ActiveValidatorCount(context.Background(), beaconState, time.CurrentEpoch(beaconState)) + validatorCount, err := helpers.ActiveValidatorCount(context.Background(), beaconState, time.CurrentEpoch(beaconState)) require.NoError(t, err) // Test churn limit calculation - resultChurn := ValidatorActivationChurnLimitDeneb(validatorCount) + resultChurn := helpers.ValidatorActivationChurnLimitDeneb(validatorCount) assert.Equal(t, test.wantedChurn, resultChurn) } } @@ -574,11 +575,11 @@ func TestActiveValidatorIndices(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - ClearCache() + helpers.ClearCache() s, err := state_native.InitializeFromProtoPhase0(tt.args.state) require.NoError(t, err) - got, err := ActiveValidatorIndices(context.Background(), s, tt.args.epoch) + got, err := helpers.ActiveValidatorIndices(context.Background(), s, tt.args.epoch) if tt.wantedErr != "" { assert.ErrorContains(t, tt.wantedErr, err) return @@ -684,12 +685,12 @@ func TestComputeProposerIndex(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - ClearCache() + helpers.ClearCache() bState := ðpb.BeaconState{Validators: tt.args.validators} stTrie, err := state_native.InitializeFromProtoUnsafePhase0(bState) require.NoError(t, err) - got, err := ComputeProposerIndex(stTrie, tt.args.indices, tt.args.seed) + got, err := helpers.ComputeProposerIndex(stTrie, tt.args.indices, tt.args.seed) if tt.wantedErr != "" { assert.ErrorContains(t, tt.wantedErr, err) return @@ -718,9 +719,9 @@ func TestIsEligibleForActivationQueue(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - ClearCache() + helpers.ClearCache() - assert.Equal(t, tt.want, IsEligibleForActivationQueue(tt.validator), "IsEligibleForActivationQueue()") + assert.Equal(t, tt.want, helpers.IsEligibleForActivationQueue(tt.validator), "IsEligibleForActivationQueue()") }) } } @@ -747,11 +748,11 @@ func TestIsIsEligibleForActivation(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - ClearCache() + helpers.ClearCache() s, err := state_native.InitializeFromProtoPhase0(tt.state) require.NoError(t, err) - assert.Equal(t, tt.want, IsEligibleForActivation(s, tt.validator), "IsEligibleForActivation()") + assert.Equal(t, tt.want, helpers.IsEligibleForActivation(s, tt.validator), "IsEligibleForActivation()") }) } } @@ -765,7 +766,7 @@ func computeProposerIndexWithValidators(validators []*ethpb.Validator, activeInd hashFunc := hash.CustomSHA256Hasher() for i := uint64(0); ; i++ { - candidateIndex, err := ComputeShuffledIndex(primitives.ValidatorIndex(i%length), length, seed, true /* shuffle */) + candidateIndex, err := helpers.ComputeShuffledIndex(primitives.ValidatorIndex(i%length), length, seed, true /* shuffle */) if err != nil { return 0, err } @@ -787,7 +788,7 @@ func computeProposerIndexWithValidators(validators []*ethpb.Validator, activeInd } func TestLastActivatedValidatorIndex_OK(t *testing.T) { - ClearCache() + helpers.ClearCache() beaconState, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{}) require.NoError(t, err) @@ -806,13 +807,13 @@ func TestLastActivatedValidatorIndex_OK(t *testing.T) { require.NoError(t, beaconState.SetValidators(validators)) require.NoError(t, beaconState.SetBalances(balances)) - index, err := LastActivatedValidatorIndex(context.Background(), beaconState) + index, err := helpers.LastActivatedValidatorIndex(context.Background(), beaconState) require.NoError(t, err) require.Equal(t, index, primitives.ValidatorIndex(3)) } func TestProposerIndexFromCheckpoint(t *testing.T) { - ClearCache() + helpers.ClearCache() e := primitives.Epoch(2) r := [32]byte{'a'} @@ -820,10 +821,10 @@ func TestProposerIndexFromCheckpoint(t *testing.T) { ids := [32]primitives.ValidatorIndex{} slot := primitives.Slot(69) // slot 5 in the Epoch ids[5] = primitives.ValidatorIndex(19) - proposerIndicesCache.Set(e, r, ids) + helpers.ProposerIndicesCache().Set(e, r, ids) c := &forkchoicetypes.Checkpoint{Root: root, Epoch: e - 1} - proposerIndicesCache.SetCheckpoint(*c, r) - id, err := ProposerIndexAtSlotFromCheckpoint(c, slot) + helpers.ProposerIndicesCache().SetCheckpoint(*c, r) + id, err := helpers.ProposerIndexAtSlotFromCheckpoint(c, slot) require.NoError(t, err) require.Equal(t, ids[5], id) }