mirror of
https://github.com/OffchainLabs/prysm.git
synced 2026-01-09 21:38:05 -05:00
b7175b3482
* Revert "Revert "Update fastssz" (#7100)"
This reverts commit b954db9704.
* Preston's patch
* Merge branch 'master' of github.com:prysmaticlabs/prysm into revert-7100-revert-6760-update-fssz
* Update fssz, add regression test case
* more HTR with fssz
* fix some tests
* only one test left
* Make it so that HTR will work
* gofmt, imports
* gofmt, imports
* fix
* Merge branch 'master' of github.com:prysmaticlabs/prysm into revert-7100-revert-6760-update-fssz
* fix
* Merge branch 'master' into revert-7100-revert-6760-update-fssz
* Merge refs/heads/master into revert-7100-revert-6760-update-fssz
* gaz
* Merge branch 'revert-7100-revert-6760-update-fssz' of github.com:prysmaticlabs/prysm into revert-7100-revert-6760-update-fssz
* Merge refs/heads/master into revert-7100-revert-6760-update-fssz
* fix test
* Merge branch 'revert-7100-revert-6760-update-fssz' of github.com:prysmaticlabs/prysm into revert-7100-revert-6760-update-fssz
* Merge refs/heads/master into revert-7100-revert-6760-update-fssz
459 lines
18 KiB
Go
459 lines
18 KiB
Go
package epoch_test
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/gogo/protobuf/proto"
|
|
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
|
|
"github.com/prysmaticlabs/go-bitfield"
|
|
"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch"
|
|
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
|
|
"github.com/prysmaticlabs/prysm/beacon-chain/state"
|
|
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
|
|
"github.com/prysmaticlabs/prysm/shared/params"
|
|
"github.com/prysmaticlabs/prysm/shared/testutil"
|
|
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
|
|
"github.com/prysmaticlabs/prysm/shared/testutil/require"
|
|
)
|
|
|
|
func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
|
|
// Generate 2 attestations.
|
|
atts := make([]*pb.PendingAttestation, 2)
|
|
for i := 0; i < len(atts); i++ {
|
|
atts[i] = &pb.PendingAttestation{
|
|
Data: ðpb.AttestationData{Source: ðpb.Checkpoint{Root: make([]byte, 32)},
|
|
Target: ðpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
|
|
},
|
|
AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF},
|
|
}
|
|
}
|
|
|
|
// Generate validators and state for the 2 attestations.
|
|
validatorCount := 1000
|
|
validators := make([]*ethpb.Validator, validatorCount)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
base := &pb.BeaconState{
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
state, err := state.InitializeFromProto(base)
|
|
require.NoError(t, err)
|
|
|
|
indices, err := epoch.UnslashedAttestingIndices(state, atts)
|
|
require.NoError(t, err)
|
|
for i := 0; i < len(indices)-1; i++ {
|
|
if indices[i] >= indices[i+1] {
|
|
t.Error("sorted indices not sorted or duplicated")
|
|
}
|
|
}
|
|
|
|
// Verify the slashed validator is filtered.
|
|
slashedValidator := indices[0]
|
|
validators = state.Validators()
|
|
validators[slashedValidator].Slashed = true
|
|
require.NoError(t, state.SetValidators(validators))
|
|
indices, err = epoch.UnslashedAttestingIndices(state, atts)
|
|
require.NoError(t, err)
|
|
for i := 0; i < len(indices); i++ {
|
|
assert.NotEqual(t, slashedValidator, indices[i], "Slashed validator %d is not filtered", slashedValidator)
|
|
}
|
|
}
|
|
|
|
func TestUnslashedAttestingIndices_DuplicatedAttestations(t *testing.T) {
|
|
// Generate 5 of the same attestations.
|
|
atts := make([]*pb.PendingAttestation, 5)
|
|
for i := 0; i < len(atts); i++ {
|
|
atts[i] = &pb.PendingAttestation{
|
|
Data: ðpb.AttestationData{Source: ðpb.Checkpoint{Root: make([]byte, 32)},
|
|
Target: ðpb.Checkpoint{Epoch: 0}},
|
|
AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF},
|
|
}
|
|
}
|
|
|
|
// Generate validators and state for the 5 attestations.
|
|
validatorCount := 1000
|
|
validators := make([]*ethpb.Validator, validatorCount)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
base := &pb.BeaconState{
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
state, err := state.InitializeFromProto(base)
|
|
require.NoError(t, err)
|
|
|
|
indices, err := epoch.UnslashedAttestingIndices(state, atts)
|
|
require.NoError(t, err)
|
|
|
|
for i := 0; i < len(indices)-1; i++ {
|
|
if indices[i] >= indices[i+1] {
|
|
t.Error("sorted indices not sorted or duplicated")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAttestingBalance_CorrectBalance(t *testing.T) {
|
|
helpers.ClearCache()
|
|
// Generate 2 attestations.
|
|
atts := make([]*pb.PendingAttestation, 2)
|
|
for i := 0; i < len(atts); i++ {
|
|
atts[i] = &pb.PendingAttestation{
|
|
Data: ðpb.AttestationData{
|
|
Target: ðpb.Checkpoint{Root: make([]byte, 32)},
|
|
Source: ðpb.Checkpoint{Root: make([]byte, 32)},
|
|
Slot: uint64(i),
|
|
},
|
|
AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
|
|
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01},
|
|
}
|
|
}
|
|
|
|
// Generate validators with balances and state for the 2 attestations.
|
|
validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
|
|
balances := make([]uint64, params.BeaconConfig().MinGenesisActiveValidatorCount)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
|
|
}
|
|
balances[i] = params.BeaconConfig().MaxEffectiveBalance
|
|
}
|
|
base := &pb.BeaconState{
|
|
Slot: 2,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
|
|
Validators: validators,
|
|
Balances: balances,
|
|
}
|
|
state, err := state.InitializeFromProto(base)
|
|
require.NoError(t, err)
|
|
|
|
balance, err := epoch.AttestingBalance(state, atts)
|
|
require.NoError(t, err)
|
|
wanted := 256 * params.BeaconConfig().MaxEffectiveBalance
|
|
assert.Equal(t, wanted, balance)
|
|
}
|
|
|
|
func TestBaseReward_AccurateRewards(t *testing.T) {
|
|
tests := []struct {
|
|
a uint64
|
|
b uint64
|
|
c uint64
|
|
}{
|
|
{params.BeaconConfig().MinDepositAmount, params.BeaconConfig().MinDepositAmount, 505976},
|
|
{30 * 1e9, 30 * 1e9, 2771282},
|
|
{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance, 2862174},
|
|
{40 * 1e9, params.BeaconConfig().MaxEffectiveBalance, 2862174},
|
|
}
|
|
for _, tt := range tests {
|
|
base := &pb.BeaconState{
|
|
Validators: []*ethpb.Validator{
|
|
{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: tt.b}},
|
|
Balances: []uint64{tt.a},
|
|
}
|
|
state, err := state.InitializeFromProto(base)
|
|
require.NoError(t, err)
|
|
c, err := epoch.BaseReward(state, 0)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, tt.c, c, "epoch.BaseReward(%d)", tt.a)
|
|
}
|
|
}
|
|
|
|
func TestProcessSlashings_NotSlashed(t *testing.T) {
|
|
base := &pb.BeaconState{
|
|
Slot: 0,
|
|
Validators: []*ethpb.Validator{{Slashed: true}},
|
|
Balances: []uint64{params.BeaconConfig().MaxEffectiveBalance},
|
|
Slashings: []uint64{0, 1e9},
|
|
}
|
|
s, err := state.InitializeFromProto(base)
|
|
require.NoError(t, err)
|
|
newState, err := epoch.ProcessSlashings(s)
|
|
require.NoError(t, err)
|
|
wanted := params.BeaconConfig().MaxEffectiveBalance
|
|
assert.Equal(t, wanted, newState.Balances()[0], "Unexpected slashed balance")
|
|
}
|
|
|
|
func TestProcessSlashings_SlashedLess(t *testing.T) {
|
|
tests := []struct {
|
|
state *pb.BeaconState
|
|
want uint64
|
|
}{
|
|
{
|
|
state: &pb.BeaconState{
|
|
Validators: []*ethpb.Validator{
|
|
{Slashed: true,
|
|
WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
|
|
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
|
|
{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance}},
|
|
Balances: []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
|
|
Slashings: []uint64{0, 1e9},
|
|
},
|
|
// penalty = validator balance / increment * (3*total_penalties) / total_balance * increment
|
|
// 3000000000 = (32 * 1e9) / (1 * 1e9) * (3*1e9) / (32*1e9) * (1 * 1e9)
|
|
want: uint64(29000000000), // 32 * 1e9 - 3000000000
|
|
},
|
|
{
|
|
state: &pb.BeaconState{
|
|
Validators: []*ethpb.Validator{
|
|
{Slashed: true,
|
|
WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
|
|
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
|
|
{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
|
|
{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
|
|
},
|
|
Balances: []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
|
|
Slashings: []uint64{0, 1e9},
|
|
},
|
|
// penalty = validator balance / increment * (3*total_penalties) / total_balance * increment
|
|
// 1000000000 = (32 * 1e9) / (1 * 1e9) * (3*1e9) / (64*1e9) * (1 * 1e9)
|
|
want: uint64(31000000000), // 32 * 1e9 - 1000000000
|
|
},
|
|
{
|
|
state: &pb.BeaconState{
|
|
Validators: []*ethpb.Validator{
|
|
{Slashed: true,
|
|
WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
|
|
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
|
|
{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
|
|
{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
|
|
},
|
|
Balances: []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
|
|
Slashings: []uint64{0, 2 * 1e9},
|
|
},
|
|
// penalty = validator balance / increment * (3*total_penalties) / total_balance * increment
|
|
// 3000000000 = (32 * 1e9) / (1 * 1e9) * (3*2e9) / (64*1e9) * (1 * 1e9)
|
|
want: uint64(29000000000), // 32 * 1e9 - 3000000000
|
|
},
|
|
{
|
|
state: &pb.BeaconState{
|
|
Validators: []*ethpb.Validator{
|
|
{Slashed: true,
|
|
WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
|
|
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement},
|
|
{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement}},
|
|
Balances: []uint64{params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement, params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement},
|
|
Slashings: []uint64{0, 1e9},
|
|
},
|
|
// penalty = validator balance / increment * (3*total_penalties) / total_balance * increment
|
|
// 3000000000 = (32 * 1e9 - 1*1e9) / (1 * 1e9) * (3*1e9) / (31*1e9) * (1 * 1e9)
|
|
want: uint64(28000000000), // 31 * 1e9 - 3000000000
|
|
},
|
|
}
|
|
|
|
for i, tt := range tests {
|
|
t.Run(string(i), func(t *testing.T) {
|
|
original := proto.Clone(tt.state)
|
|
s, err := state.InitializeFromProto(tt.state)
|
|
require.NoError(t, err)
|
|
newState, err := epoch.ProcessSlashings(s)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, tt.want, newState.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d", original, newState.Balances()[0])
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestProcessFinalUpdates_CanProcess(t *testing.T) {
|
|
s := buildState(t, params.BeaconConfig().SlotsPerHistoricalRoot-1, params.BeaconConfig().SlotsPerEpoch)
|
|
ce := helpers.CurrentEpoch(s)
|
|
ne := ce + 1
|
|
require.NoError(t, s.SetEth1DataVotes([]*ethpb.Eth1Data{}))
|
|
balances := s.Balances()
|
|
balances[0] = 31.75 * 1e9
|
|
balances[1] = 31.74 * 1e9
|
|
require.NoError(t, s.SetBalances(balances))
|
|
|
|
slashings := s.Slashings()
|
|
slashings[ce] = 0
|
|
require.NoError(t, s.SetSlashings(slashings))
|
|
mixes := s.RandaoMixes()
|
|
mixes[ce] = []byte{'A'}
|
|
require.NoError(t, s.SetRandaoMixes(mixes))
|
|
newS, err := epoch.ProcessFinalUpdates(s)
|
|
require.NoError(t, err)
|
|
|
|
// Verify effective balance is correctly updated.
|
|
assert.Equal(t, params.BeaconConfig().MaxEffectiveBalance, newS.Validators()[0].EffectiveBalance, "Effective balance incorrectly updated")
|
|
assert.Equal(t, uint64(31*1e9), newS.Validators()[1].EffectiveBalance, "Effective balance incorrectly updated")
|
|
|
|
// Verify slashed balances correctly updated.
|
|
assert.Equal(t, newS.Slashings()[ce], newS.Slashings()[ne], "Unexpected slashed balance")
|
|
|
|
// Verify randao is correctly updated in the right position.
|
|
mix, err := newS.RandaoMixAtIndex(ne)
|
|
assert.NoError(t, err)
|
|
assert.DeepNotEqual(t, params.BeaconConfig().ZeroHash[:], mix, "latest RANDAO still zero hashes")
|
|
|
|
// Verify historical root accumulator was appended.
|
|
assert.Equal(t, 1, len(newS.HistoricalRoots()), "Unexpected slashed balance")
|
|
assert.NotNil(t, newS.CurrentEpochAttestations(), "Nil value stored in current epoch attestations instead of empty slice")
|
|
}
|
|
|
|
func TestProcessRegistryUpdates_NoRotation(t *testing.T) {
|
|
base := &pb.BeaconState{
|
|
Slot: 5 * params.BeaconConfig().SlotsPerEpoch,
|
|
Validators: []*ethpb.Validator{
|
|
{ExitEpoch: params.BeaconConfig().MaxSeedLookahead},
|
|
{ExitEpoch: params.BeaconConfig().MaxSeedLookahead},
|
|
},
|
|
Balances: []uint64{
|
|
params.BeaconConfig().MaxEffectiveBalance,
|
|
params.BeaconConfig().MaxEffectiveBalance,
|
|
},
|
|
FinalizedCheckpoint: ðpb.Checkpoint{Root: make([]byte, 32)},
|
|
}
|
|
state, err := state.InitializeFromProto(base)
|
|
require.NoError(t, err)
|
|
newState, err := epoch.ProcessRegistryUpdates(state)
|
|
require.NoError(t, err)
|
|
for i, validator := range newState.Validators() {
|
|
assert.Equal(t, params.BeaconConfig().MaxSeedLookahead, validator.ExitEpoch, "Could not update registry %d", i)
|
|
}
|
|
}
|
|
|
|
func TestProcessRegistryUpdates_EligibleToActivate(t *testing.T) {
|
|
base := &pb.BeaconState{
|
|
Slot: 5 * params.BeaconConfig().SlotsPerEpoch,
|
|
FinalizedCheckpoint: ðpb.Checkpoint{Epoch: 6, Root: make([]byte, 32)},
|
|
}
|
|
limit, err := helpers.ValidatorChurnLimit(0)
|
|
require.NoError(t, err)
|
|
for i := uint64(0); i < limit+10; i++ {
|
|
base.Validators = append(base.Validators, ðpb.Validator{
|
|
ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
|
|
ActivationEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
})
|
|
}
|
|
state, err := state.InitializeFromProto(base)
|
|
currentEpoch := helpers.CurrentEpoch(state)
|
|
newState, err := epoch.ProcessRegistryUpdates(state)
|
|
require.NoError(t, err)
|
|
for i, validator := range newState.Validators() {
|
|
assert.Equal(t, currentEpoch+1, validator.ActivationEligibilityEpoch, "Could not update registry %d, unexpected activation eligibility epoch", i)
|
|
if uint64(i) < limit && validator.ActivationEpoch != helpers.ActivationExitEpoch(currentEpoch) {
|
|
t.Errorf("Could not update registry %d, validators failed to activate: wanted activation epoch %d, got %d",
|
|
i, helpers.ActivationExitEpoch(currentEpoch), validator.ActivationEpoch)
|
|
}
|
|
if uint64(i) >= limit && validator.ActivationEpoch != params.BeaconConfig().FarFutureEpoch {
|
|
t.Errorf("Could not update registry %d, validators should not have been activated, wanted activation epoch: %d, got %d",
|
|
i, params.BeaconConfig().FarFutureEpoch, validator.ActivationEpoch)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestProcessRegistryUpdates_ActivationCompletes(t *testing.T) {
|
|
base := &pb.BeaconState{
|
|
Slot: 5 * params.BeaconConfig().SlotsPerEpoch,
|
|
Validators: []*ethpb.Validator{
|
|
{ExitEpoch: params.BeaconConfig().MaxSeedLookahead,
|
|
ActivationEpoch: 5 + params.BeaconConfig().MaxSeedLookahead + 1},
|
|
{ExitEpoch: params.BeaconConfig().MaxSeedLookahead,
|
|
ActivationEpoch: 5 + params.BeaconConfig().MaxSeedLookahead + 1},
|
|
},
|
|
FinalizedCheckpoint: ðpb.Checkpoint{Root: make([]byte, 32)},
|
|
}
|
|
state, err := state.InitializeFromProto(base)
|
|
require.NoError(t, err)
|
|
newState, err := epoch.ProcessRegistryUpdates(state)
|
|
require.NoError(t, err)
|
|
for i, validator := range newState.Validators() {
|
|
assert.Equal(t, params.BeaconConfig().MaxSeedLookahead, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)
|
|
}
|
|
}
|
|
|
|
func TestProcessRegistryUpdates_ValidatorsEjected(t *testing.T) {
|
|
base := &pb.BeaconState{
|
|
Slot: 0,
|
|
Validators: []*ethpb.Validator{
|
|
{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
EffectiveBalance: params.BeaconConfig().EjectionBalance - 1,
|
|
},
|
|
{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
EffectiveBalance: params.BeaconConfig().EjectionBalance - 1,
|
|
},
|
|
},
|
|
FinalizedCheckpoint: ðpb.Checkpoint{Root: make([]byte, 32)},
|
|
}
|
|
state, err := state.InitializeFromProto(base)
|
|
require.NoError(t, err)
|
|
newState, err := epoch.ProcessRegistryUpdates(state)
|
|
require.NoError(t, err)
|
|
for i, validator := range newState.Validators() {
|
|
assert.Equal(t, params.BeaconConfig().MaxSeedLookahead+1, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)
|
|
}
|
|
}
|
|
|
|
func TestProcessRegistryUpdates_CanExits(t *testing.T) {
|
|
e := uint64(5)
|
|
exitEpoch := helpers.ActivationExitEpoch(e)
|
|
minWithdrawalDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
|
|
base := &pb.BeaconState{
|
|
Slot: e * params.BeaconConfig().SlotsPerEpoch,
|
|
Validators: []*ethpb.Validator{
|
|
{
|
|
ExitEpoch: exitEpoch,
|
|
WithdrawableEpoch: exitEpoch + minWithdrawalDelay},
|
|
{
|
|
ExitEpoch: exitEpoch,
|
|
WithdrawableEpoch: exitEpoch + minWithdrawalDelay},
|
|
},
|
|
FinalizedCheckpoint: ðpb.Checkpoint{Root: make([]byte, 32)},
|
|
}
|
|
state, err := state.InitializeFromProto(base)
|
|
require.NoError(t, err)
|
|
newState, err := epoch.ProcessRegistryUpdates(state)
|
|
require.NoError(t, err)
|
|
for i, validator := range newState.Validators() {
|
|
assert.Equal(t, exitEpoch, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)
|
|
}
|
|
}
|
|
|
|
func buildState(t testing.TB, slot uint64, validatorCount uint64) *state.BeaconState {
|
|
validators := make([]*ethpb.Validator, validatorCount)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
|
|
}
|
|
}
|
|
validatorBalances := make([]uint64, len(validators))
|
|
for i := 0; i < len(validatorBalances); i++ {
|
|
validatorBalances[i] = params.BeaconConfig().MaxEffectiveBalance
|
|
}
|
|
latestActiveIndexRoots := make(
|
|
[][]byte,
|
|
params.BeaconConfig().EpochsPerHistoricalVector,
|
|
)
|
|
for i := 0; i < len(latestActiveIndexRoots); i++ {
|
|
latestActiveIndexRoots[i] = params.BeaconConfig().ZeroHash[:]
|
|
}
|
|
latestRandaoMixes := make(
|
|
[][]byte,
|
|
params.BeaconConfig().EpochsPerHistoricalVector,
|
|
)
|
|
for i := 0; i < len(latestRandaoMixes); i++ {
|
|
latestRandaoMixes[i] = params.BeaconConfig().ZeroHash[:]
|
|
}
|
|
s := testutil.NewBeaconState()
|
|
if err := s.SetSlot(slot); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if err := s.SetBalances(validatorBalances); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if err := s.SetValidators(validators); err != nil {
|
|
t.Error(err)
|
|
}
|
|
return s
|
|
}
|