mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-24 12:27:18 +00:00
6d2a2ebadf
* Remove custody (#3986)
* Update proto fields
* Updated block operations
* Fixed all block operation tests
* Fixed tests part 1
* Fixed tests part 1
* All tests pass
* Clean up
* Skip spec test
* Fixed ssz test
* Skip ssz test
* Skip mainnet tests
* Update beacon-chain/operations/attestation.go
* Update beacon-chain/operations/attestation.go
* Decoy flip flop check (#3987)
* Bounce attack check (#3989)
* New store values
* Update process block
* Update process attestation
* Update tests
* Helper
* Fixed blockchain package tests
* Update beacon-chain/blockchain/forkchoice/process_block.go
* Conflict
* Unskip mainnet spec tests (#3998)
* Starting
* Fixed attestation mainnet test
* Unskip ssz static and block processing tests
* Fixed workspace
* fixed workspace
* fixed workspace
* Update beacon-chain/core/blocks/block_operations.go
* Unskip minimal spec tests (#3999)
* Starting
* Fixed attestation mainnet test
* Unskip ssz static and block processing tests
* Fixed workspace
* fixed workspace
* fixed workspace
* Update workspace
* Unskip all minimal spec tests
* Update workspace for general test
* Unskip test (#4001)
* Update minimal seconds per slot to 6 (#3978)
* Bounce attack tests (#3993)
* New store values
* Update process block
* Update process attestation
* Update tests
* Helper
* Fixed blockchain package tests
* Slots since epoch starts tests
* Update justified checkpt tests
* Conflict
* Fixed logic
* Update process_block.go
* Use helper
* Conflict
* Merge branch 'master' of https://github.com/prysmaticlabs/prysm into v0.9.1
* Conflict
* Fixed failed tests
* Lower MinGenesisActiveValidatorCount to 16384 (#4100)
* Fork choice beacon block checks (#4107)
* Prevent future blocks check and test
* Removed old code
* Update aggregation proto (#4121)
* Update def
* Update spec test
* Conflict
* Update workspace
* patch
* Resolve conflict
* Patch
* Change workspace
* Update ethereumapis to a forked branch at commit 6eb1193e47
* Fixed all the tests
* Merge branch 'v0.9.2' of https://github.com/prysmaticlabs/prysm into conflict
* fix patch
* Need to regenerate test data
* Merge branch 'master' into v0.9.2
* Merge branch 'master' of https://github.com/prysmaticlabs/prysm into v0.9.2
* Enable snappy compression for all (#4157)
* enable snappy compression for all
* enable snappy compression for all
* enable snappy compression for all
* enable snappy compression for all
* Validate aggregate and proof subscriber (#4159)
* Merge branch 'master' of https://github.com/prysmaticlabs/prysm into v0.9.2
* Conflict
* Update workspace
* Conflict
* Conflict
* Conflict
* Merge branch 'master' into v0.9.2
* Merge branch 'master' into v0.9.2
* Conflict
* Merge branch 'v0.9.2' of https://github.com/prysmaticlabs/prysm into v0.9.2
* Remove migrate to snappy (#4205)
* Feature flag: Deprecate --prune-states, release to all (#4204)
* Deprecated prune-states, release to all
* imports
* remote unused import
* remove unused import
* Rm prune state test
* gaz
* Refactoring for dynamic pubsub subscriptions for non-aggregated attestations (#4189)
* checkpoint progress
* chkpt
* checkpoint progress
* put pipeline in its own file
* remove unused imports
* add test, it's failing though
* fix test
* remove head state issue
* add clear db flag to e2e
* add some more error handling, debug logging
* skip processing if chain has not started
* fix test
* wrap in go routine to see if anything breaks
* remove duplicated topic
* Add a regression test. Thanks @nisdas for finding the original problem. May it never happen again *fingers crossed*
* Comments
* gofmt
* comment out with TODO
* Sync with master
* Sync with master
* RPC servers use attestation pool (#4223)
* Merge branch 'master' of https://github.com/prysmaticlabs/prysm into v0.9.2
* Refactor RPC to Fully Utilize Ethereum APIs (#4243)
* include attester as a file in the validator server
* remove old proposer server impl
* include new patch and properly sync changes
* align with public pbs
* ensure matches rpc def
* fix up status tests
* resolve all broken test files in the validator rpc package
* gazelle include
* fix up the duties implementation
* fixed up all get duties functions
* all tests pass
* utilize new ethereum apis
* amend validator client to use the new beacon node validator rpc client
* fix up most of validator items
* added in mock
* fix up test
* readd test
* add chain serv mock
* fix a few more validator methods
* all validator tests passingggg
* fix broken test
* resolve even more broken tests
* all tests passsssss
* fix lint
* try PR
* fix up test
* resolve broken other tests
* Sync with master
* Merge branch 'v0.9.2' of https://github.com/prysmaticlabs/prysm into v0.9.2
* Aggregate and proof subscriber (#4240)
* Added subscribers
* Fixed conflict
* Tests
* fix up patch
* Use upstream pb
* include latest patch
* Fmt
* Save state before head block
* skip tests (#4275)
* Delete block attestations from the pool (#4241)
* Added subscribers
* Clean up
* Fixed conflict
* Delete atts in pool in validate pipeline
* Moved it to subscriber
* Merge branch 'v0.9.2' of https://github.com/prysmaticlabs/prysm into use-att-pool-3
* Test
* Fixed test
* Initial work on voluntary exit (#4207)
* Initial implementation of voluntary exit: RPC call
* Update for recent merges
* Break out validation logic for voluntary exits to core module
* RequestExit -> ProposeExit
* Decrease exit package visibility
* Move to operation feed
* Wrap errors
* Fix critical proposer selection bug #4259 (#4265)
* fix critical proposer selection bug #4259
* gofmt
* add 1 more validator to make it 5
* more tests
* Fixed archivedProposerIndex
* Fixed TestFilterAttestation_OK
* Refactor ComputeProposerIndex, add regression test for potential out of range panic
* handle case of nil validator
* Update validators_test.go
* Merge branch 'master' of github.com:prysmaticlabs/prysm into v0.9.2
* Leftover merge files, oops
* gaz
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge branch 'master' of https://github.com/prysmaticlabs/geth-sharding into v0.9.2
* Fixes Duplicate Validator Bug (#4322)
* Update dict
* Test helper
* Regression test
* Comment
* Reset test cache
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* fixes after PR #4328
* Complete attestation pool for run time (#4286)
* Added subscribers
* Fixed conflict
* Delete atts in pool in validate pipeline
* Moved it to subscriber
* Test
* Fixed test
* New curl for forkchoice attestations
* Starting att pool service for fork choice
* Update pool interface
* Update pool interface
* Update sync and node
* Lint
* Gazelle
* Updated servers, filled in missing functionalities
* RPC working with 1 beacon node 64 validators
* Started writing tests. Yay
* Test to aggregate and save multiple fork choice atts
* Tests for BatchAttestations for fork choice
* Fixed exisiting tests
* Minor fixes
* Fmt
* Added batch saves
* Lint
* Mo tests yay
* Delete test
* Fmt
* Update interval
* Fixed aggregation broadcast
* Clean up based on design review comment
* Fixed setupBeaconChain
* Raul's feedback. s/error/err
* resolve conflicts
* Merge branch 'v0.9.2' of github.com:prysmaticlabs/prysm into v0.9.2
* Merge branch 'master' of github.com:prysmaticlabs/prysm into v0.9.2
* Merge refs/heads/master into v0.9.2
* Removed old protos and fixed tests (#4336)
* Merge refs/heads/master into v0.9.2
* Disallow duplicated indices and test (#4339)
* Explicit use of GENESIS_SLOT in fork choice (#4343)
* Update from 2 to 3 (#4345)
* Remove verify unaggregated attestation when aggregating (#4347)
* use slot ticker instead of run every (#4348)
* Add context check for unbounded loop work (#4346)
* Revert "Explicit use of GENESIS_SLOT in fork choice (#4343)" (#4349)
This reverts commit d3f6753c77f8f733563d00ab649c5159b2c2926f.
* Refactor Powchain Service (#4306)
* add data structures
* generate proto
* add in new fields
* add comments
* add new mock state
* add new mock state
* add new methods
* some more changes
* check genesis time properly
* lint
* fix refs
* fix tests
* lint
* lint
* lint
* gaz
* fix lint
* raul's comments
* use one method
* fix test
* raul's comment
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
* Ensure best better-justification is stored for fork choice (#4342)
* Ensure best better-justification is stored. Minor refactor
* Tests
* Merge refs/heads/v0.9.2 into better-best-justified
* Merge refs/heads/v0.9.2 into better-best-justified
* Ensure that epoch of attestation slot matches the target epoch (#4341)
* Disallow duplicated indices and test
* Add slot to target epoch check to on_attestation
* Add slot to target epoch check to process_attestation
* Merge branch 'v0.9.2' of git+ssh://github.com/prysmaticlabs/prysm into no-dup-att-indices
* Fixed TestProcessAttestations_PrevEpochFFGDataMismatches
* Merge refs/heads/v0.9.2 into no-dup-att-indices
* Merge refs/heads/v0.9.2 into no-dup-att-indices
* Merge refs/heads/v0.9.2 into no-dup-att-indices
* Merge refs/heads/v0.9.2 into no-dup-att-indices
* Merge refs/heads/v0.9.2 into no-dup-att-indices
* Merge refs/heads/v0.9.2 into no-dup-att-indices
* Merge refs/heads/v0.9.2 into no-dup-att-indices
* Update beacon-chain/blockchain/forkchoice/process_attestation_test.go
Co-Authored-By: Raul Jordan <raul@prysmaticlabs.com>
* Merge refs/heads/v0.9.2 into no-dup-att-indices
* Filter viable branches in fork choice (#4355)
* Only activate upon finality (#4359)
* Updated functions
* Tests
* Merge branch 'v0.9.2' of git+ssh://github.com/prysmaticlabs/prysm into queue-fix-on-finality
* Comment
* Merge refs/heads/v0.9.2 into queue-fix-on-finality
* Fixed failing test from 4359 (#4360)
* Fixed
* Skip registry spec tests
* Wait for state to be initialized at least once before running slot ticker based on genesis time (#4364)
* Sync with master
* Fix checkpoint root to use genesis block root (#4368)
* Return an error on nil head state in fork choice (#4369)
* Return error if nil head state
* Fixed tests. Saved childen blocks state
Co-authored-by: terence tsao <terence@prysmaticlabs.com>
* Update metrics every epoch (#4367)
* return empty slice if state is nil (#4365)
* Merge branch 'master' of github.com:prysmaticlabs/prysm into v0.9.2
* Merge refs/heads/master into v0.9.2
* Pubsub: Broadcast attestations to committee based subnets (#4316)
* Working on un-aggregated pubsub topics
* update subscriber to call pool
* checkpointing
* fix
* untested message validation
* minor fixes
* rename slotsSinceGenesis to slotsSince
* some progress on a unit test, subscribe is not being called still...
* dont change topic
* need to set the data on the message
* restore topic
* fixes
* some helpful parameter changes for mainnet operations
* lint
* Terence feedback
* unskip e2e
* Unit test for validate committee index beacon attestation
* PR feedbacK
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
* Merge branch 'master' of https://github.com/prysmaticlabs/geth-sharding into resolveConflicts
* remove condition
* Remove unused operation pool (#4361)
* Merge refs/heads/master into v0.9.2
* Aggregate attestations periodically (#4376)
* Persist ETH1 Data to Disk (#4329)
* add data structures
* generate proto
* add in new fields
* add comments
* add new mock state
* add new mock state
* add new methods
* some more changes
* check genesis time properly
* lint
* fix refs
* fix tests
* lint
* lint
* lint
* gaz
* adding in new proto message
* remove outdated vars
* add new changes
* remove latest eth1data
* continue refactoring
* finally works
* lint
* fix test
* fix all tests
* fix all tests again
* fix build
* change back
* add full eth1 test
* fix logs and test
* add constant
* changes
* fix bug
* lint
* fix another bug
* change back
* Apply suggestions from code review
Co-Authored-By: Raul Jordan <raul@prysmaticlabs.com>
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
Co-authored-by: Raul Jordan <raul@prysmaticlabs.com>
* Fixed VerifyIndexedAttestation (#4382)
* rm signing root (#4381)
* rm signing root
* Fixed VerifyIndexedAttestation
* Check proposer slashed status inside ProcessBlockHeaderNoVerify
* Fixed TestUpdateJustified_CouldUpdateBest
Co-authored-by: terence tsao <terence@prysmaticlabs.com>
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
* Remove Redundant Trie Generation (#4383)
* remove trie generation
* remove deposit hashes
* Merge branch 'master' of https://github.com/prysmaticlabs/geth-sharding into v0.9.2
* fix build
* Conflict
* Implement StreamAttestations RPC Endpoint (#4390)
* started attestation stream
* stream attestations test
* on slot tick test passing
* imports
* gaz
* Update beacon-chain/rpc/beacon/attestations_test.go
Co-Authored-By: shayzluf <thezluf@gmail.com>
Co-authored-by: shayzluf <thezluf@gmail.com>
* Fixed goimport (#4394)
* Use custom stateutil ssz for ssz HTR spec tests (#4396)
* Use custom stateutil ssz for ssz HTR spec tests
* gofmt
* Merge branch 'master' of github.com:prysmaticlabs/prysm into v0.9.2
* Merge refs/heads/master into v0.9.2
* set mainnet to be the default for build and run (#4398)
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
* Merge branch 'master' of github.com:prysmaticlabs/prysm into v0.9.2
* Merge branch 'master' of github.com:prysmaticlabs/prysm into v0.9.2
* gracefully handle deduplicated registration of topic validators (#4399)
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
* SSZ: temporarily disable roots cache until cache issues can be resolved (#4407)
* temporarily disable roots cache until cache issues can be resolved
* Also use custom ssz for spectests
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
* Remove process block attestations as separate routine (#4408)
* Removed old save/process block atts
* Fixed tests
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
* Save Deposit Cache to Disk (#4384)
* change to protos
* fix build
* glue everything together
* fix test
* raul's review
* preston's comments
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
* Fix activation queue sorting (#4409)
* Removed old save/process block atts
* Fixed tests
* Proper sorting by eligibility epoch then by indices
* Deleted old colde
* Merge branch 'master' of github.com:prysmaticlabs/prysm into v0.9.2
* Merge branch 'master' into v0.9.2
* Merge refs/heads/master into v0.9.2
* stop recursive lookup if context is cancelled (#4420)
* Fix proposal bug (#4419)
* Add Pending Deposits Safely (#4422)
* safely prune cache
* use proper method
* preston's,terence's reviews and comments
* revert change to build files
* use as feature config instead
* Release custom state ssz (#4421)
* Release custom state ssz, change all HTR of beacon state to use custom method
* typo
* use mainnet config
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
* Merge branch 'master' of github.com:prysmaticlabs/prysm into v0.9.2
* Update initial sync save justified to align with v0.9.3 (#4432)
* Merge refs/heads/master into v0.9.2
* Merge refs/heads/master into v0.9.2
* fix build
* don't blacklist on pubsub (#4435)
* Fix Flakey Slot Ticker Test (#4434)
* use interface instead for the slot ticker
* fixed up flakey tests
* add gen time
* get duties comment
* fix lifecycle test
* more fixes
* Configurable min genesis delay (#4437)
* Configurable min genesis delay based on https://github.com/ethereum/eth2.0-specs/pull/1557
* remove feature flag for genesis delay
* fix
* demo config feedback
* patch readme
* save keys unencrypted for validators (#4439)
* Add new demo configuration targeting mainnet scale (#4397)
* Add new demo configuration targeting mainnet, with 1/10th of the deposit value
* reduce quotant by 1/10th. Use 1/10th mainnet values
* only change the inactivity quotant
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
* Save justified checkpoint state (#4433)
* Save justified checkpoint state
* Lint
* Feedback
* Fixed test
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
* Update shared/testutil/deposits.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update proto/testing/ssz_regression_test.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/core/epoch/epoch_processing.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/operations/attestations/kv/forkchoice.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/operations/attestations/pool.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/operations/attestations/pool.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/powchain/log_processing_test.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/rpc/validator/exit_test.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/operations/attestations/service.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/sync/subscriber_beacon_blocks_test.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/sync/subscriber_beacon_blocks_test.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/sync/subscriber.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/sync/subscriber.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/rpc/validator/proposer.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/rpc/validator/exit_test.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/rpc/validator/exit_test.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/operations/attestations/prepare_forkchoice.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/powchain/log_processing_test.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/operations/attestations/pool.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/powchain/log_processing_test.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/rpc/aggregator/server.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/rpc/validator/exit.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/rpc/validator/exit_test.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/rpc/validator/exit_test.go
Co-Authored-By: Ivan Martinez <ivanthegreatdev@gmail.com>
* Update beacon-chain/cache/depositcache/pending_deposits.go
* Update beacon-chain/cache/depositcache/pending_deposits_test.go
* Update beacon-chain/rpc/validator/proposer.go
* Merge refs/heads/master into v0.9.2
* Fix e2e genesis delay issues (#4442)
* fix e2e genesis delay issues
* register flag
* typo
* Update shared/featureconfig/config.go
Co-Authored-By: Nishant Das <nishdas93@gmail.com>
* Apply suggestions from code review
Co-Authored-By: Nishant Das <nishdas93@gmail.com>
* skip demo e2e
* fix validator
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
Co-authored-by: terence tsao <terence@prysmaticlabs.com>
Co-authored-by: Nishant Das <nish1993@hotmail.com>
Co-authored-by: Ivan Martinez <ivanthegreatdev@gmail.com>
* Batch Eth1 RPC Calls (#4392)
* add new methods
* get it working
* optimize past deposit logs processing
* revert change
* fix all tests
* use mock
* lint
* lint
* check for nil
* stop panics
* Apply suggestions from code review
Co-Authored-By: terence tsao <terence@prysmaticlabs.com>
* Terence's Review
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
Co-authored-by: terence tsao <terence@prysmaticlabs.com>
873 lines
24 KiB
Go
873 lines
24 KiB
Go
package helpers
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/gogo/protobuf/proto"
|
|
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
|
|
"github.com/prysmaticlabs/go-bitfield"
|
|
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
|
|
"github.com/prysmaticlabs/prysm/shared/featureconfig"
|
|
"github.com/prysmaticlabs/prysm/shared/params"
|
|
"github.com/prysmaticlabs/prysm/shared/sliceutil"
|
|
)
|
|
|
|
func TestComputeCommittee_WithoutCache(t *testing.T) {
|
|
// Create 10 committees
|
|
committeeCount := uint64(10)
|
|
validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize
|
|
validators := make([]*ethpb.Validator, validatorCount)
|
|
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
Slot: 200,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
epoch := CurrentEpoch(state)
|
|
indices, err := ActiveValidatorIndices(state, epoch)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
committees, err := ComputeCommittee(indices, seed, 0, 1 /* Total committee*/)
|
|
if err != nil {
|
|
t.Errorf("could not compute committee: %v", err)
|
|
}
|
|
|
|
// Test shuffled indices are correct for index 5 committee
|
|
index := uint64(5)
|
|
committee5, err := ComputeCommittee(indices, seed, index, committeeCount)
|
|
if err != nil {
|
|
t.Errorf("could not compute committee: %v", err)
|
|
}
|
|
start := sliceutil.SplitOffset(validatorCount, committeeCount, index)
|
|
end := sliceutil.SplitOffset(validatorCount, committeeCount, index+1)
|
|
|
|
if !reflect.DeepEqual(committees[start:end], committee5) {
|
|
t.Error("committee has different shuffled indices")
|
|
}
|
|
|
|
// Test shuffled indices are correct for index 9 committee
|
|
index = uint64(9)
|
|
committee9, err := ComputeCommittee(indices, seed, index, committeeCount)
|
|
if err != nil {
|
|
t.Errorf("could not compute committee: %v", err)
|
|
}
|
|
start = sliceutil.SplitOffset(validatorCount, committeeCount, index)
|
|
end = sliceutil.SplitOffset(validatorCount, committeeCount, index+1)
|
|
|
|
if !reflect.DeepEqual(committees[start:end], committee9) {
|
|
t.Error("committee has different shuffled indices")
|
|
}
|
|
}
|
|
|
|
func TestAttestationParticipants_NoCommitteeCache(t *testing.T) {
|
|
committeeSize := uint64(16)
|
|
validators := make([]*ethpb.Validator, committeeSize*params.BeaconConfig().SlotsPerEpoch)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
|
|
state := &pb.BeaconState{
|
|
Slot: params.BeaconConfig().SlotsPerEpoch,
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
attestationData := ðpb.AttestationData{}
|
|
|
|
tests := []struct {
|
|
attestationSlot uint64
|
|
bitfield bitfield.Bitlist
|
|
wanted []uint64
|
|
}{
|
|
{
|
|
attestationSlot: 3,
|
|
bitfield: bitfield.Bitlist{0x07},
|
|
wanted: []uint64{355, 416},
|
|
},
|
|
{
|
|
attestationSlot: 2,
|
|
bitfield: bitfield.Bitlist{0x05},
|
|
wanted: []uint64{447},
|
|
},
|
|
{
|
|
attestationSlot: 11,
|
|
bitfield: bitfield.Bitlist{0x07},
|
|
wanted: []uint64{67, 508},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
attestationData.Target = ðpb.Checkpoint{Epoch: 0}
|
|
attestationData.Slot = tt.attestationSlot
|
|
|
|
committee, err := BeaconCommitteeFromState(state, tt.attestationSlot, 0 /* committee index */)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
result, err := AttestingIndices(tt.bitfield, committee)
|
|
if err != nil {
|
|
t.Errorf("Failed to get attestation participants: %v", err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(tt.wanted, result) {
|
|
t.Errorf(
|
|
"Result indices was an unexpected value. Wanted %d, got %d",
|
|
tt.wanted,
|
|
result,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAttestingIndicesWithBeaconCommitteeWithoutCache_Ok(t *testing.T) {
|
|
committeeSize := uint64(16)
|
|
validators := make([]*ethpb.Validator, committeeSize*params.BeaconConfig().SlotsPerEpoch)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
|
|
state := &pb.BeaconState{
|
|
Slot: params.BeaconConfig().SlotsPerEpoch,
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
attestationData := ðpb.AttestationData{}
|
|
|
|
tests := []struct {
|
|
attestationSlot uint64
|
|
bitfield bitfield.Bitlist
|
|
wanted []uint64
|
|
}{
|
|
{
|
|
attestationSlot: 3,
|
|
bitfield: bitfield.Bitlist{0x07},
|
|
wanted: []uint64{355, 416},
|
|
},
|
|
{
|
|
attestationSlot: 2,
|
|
bitfield: bitfield.Bitlist{0x05},
|
|
wanted: []uint64{447},
|
|
},
|
|
{
|
|
attestationSlot: 11,
|
|
bitfield: bitfield.Bitlist{0x07},
|
|
wanted: []uint64{67, 508},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
attestationData.Target = ðpb.Checkpoint{Epoch: 0}
|
|
attestationData.Slot = tt.attestationSlot
|
|
committee, err := BeaconCommitteeWithoutCache(state, tt.attestationSlot, 0 /* committee index */)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
result, err := AttestingIndices(tt.bitfield, committee)
|
|
if err != nil {
|
|
t.Errorf("Failed to get attestation participants: %v", err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(tt.wanted, result) {
|
|
t.Errorf(
|
|
"Result indices was an unexpected value. Wanted %d, got %d",
|
|
tt.wanted,
|
|
result,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAttestationParticipants_EmptyBitfield(t *testing.T) {
|
|
validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
attestationData := ðpb.AttestationData{Target: ðpb.Checkpoint{}}
|
|
|
|
committee, err := BeaconCommitteeFromState(state, attestationData.Slot, attestationData.CommitteeIndex)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
indices, err := AttestingIndices(bitfield.NewBitlist(128), committee)
|
|
if err != nil {
|
|
t.Fatalf("attesting indices failed: %v", err)
|
|
}
|
|
|
|
if len(indices) != 0 {
|
|
t.Errorf("Attesting indices are non-zero despite an empty bitfield being provided; Size %d", len(indices))
|
|
}
|
|
}
|
|
|
|
func TestVerifyBitfieldLength_OK(t *testing.T) {
|
|
bf := bitfield.Bitlist{0xFF, 0x01}
|
|
committeeSize := uint64(8)
|
|
if err := VerifyBitfieldLength(bf, committeeSize); err != nil {
|
|
t.Errorf("bitfield is not validated when it was supposed to be: %v", err)
|
|
}
|
|
|
|
bf = bitfield.Bitlist{0xFF, 0x07}
|
|
committeeSize = 10
|
|
if err := VerifyBitfieldLength(bf, committeeSize); err != nil {
|
|
t.Errorf("bitfield is not validated when it was supposed to be: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCommitteeAssignment_CanRetrieve(t *testing.T) {
|
|
// Initialize test with 128 validators, each slot and each index gets 2 validators.
|
|
validators := make([]*ethpb.Validator, 2*params.BeaconConfig().SlotsPerEpoch)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
Slot: params.BeaconConfig().SlotsPerEpoch,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
tests := []struct {
|
|
index uint64
|
|
slot uint64
|
|
committee []uint64
|
|
committeeIndex uint64
|
|
isProposer bool
|
|
proposerSlot uint64
|
|
}{
|
|
{
|
|
index: 0,
|
|
slot: 92,
|
|
committee: []uint64{46, 0},
|
|
committeeIndex: 0,
|
|
isProposer: false,
|
|
},
|
|
{
|
|
index: 1,
|
|
slot: 70,
|
|
committee: []uint64{1, 58},
|
|
committeeIndex: 0,
|
|
isProposer: true,
|
|
proposerSlot: 91,
|
|
},
|
|
{
|
|
index: 11,
|
|
slot: 64,
|
|
committee: []uint64{30, 11},
|
|
committeeIndex: 0,
|
|
isProposer: false,
|
|
},
|
|
}
|
|
|
|
for i, tt := range tests {
|
|
t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
|
|
committee, committeeIndex, slot, proposerSlot, err := CommitteeAssignment(state, tt.slot/params.BeaconConfig().SlotsPerEpoch, tt.index)
|
|
if err != nil {
|
|
t.Fatalf("failed to execute NextEpochCommitteeAssignment: %v", err)
|
|
}
|
|
if committeeIndex != tt.committeeIndex {
|
|
t.Errorf("wanted committeeIndex %d, got committeeIndex %d for validator index %d",
|
|
tt.committeeIndex, committeeIndex, tt.index)
|
|
}
|
|
if slot != tt.slot {
|
|
t.Errorf("wanted slot %d, got slot %d for validator index %d",
|
|
tt.slot, slot, tt.index)
|
|
}
|
|
if proposerSlot != tt.proposerSlot {
|
|
t.Errorf("wanted proposer slot %d, got proposer slot %d for validator index %d",
|
|
tt.proposerSlot, proposerSlot, tt.index)
|
|
}
|
|
if !reflect.DeepEqual(committee, tt.committee) {
|
|
t.Errorf("wanted committee %v, got committee %v for validator index %d",
|
|
tt.committee, committee, tt.index)
|
|
}
|
|
if proposerSlot != tt.proposerSlot {
|
|
t.Errorf("wanted proposer slot slot %d, got slot %d for validator index %d",
|
|
tt.slot, slot, tt.index)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommitteeAssignment_CantFindValidator(t *testing.T) {
|
|
validators := make([]*ethpb.Validator, 1)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
Slot: params.BeaconConfig().SlotsPerEpoch,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
index := uint64(10000)
|
|
_, _, _, _, err := CommitteeAssignment(state, 1, index)
|
|
if err != nil && !strings.Contains(err.Error(), "not found in assignments") {
|
|
t.Errorf("Wanted 'not found in assignments', received %v", err)
|
|
}
|
|
}
|
|
|
|
// Test helpers.CommitteeAssignments against the results of helpers.CommitteeAssignment by validator
|
|
// index. Warning: this test is a bit slow!
|
|
func TestCommitteeAssignments_AgreesWithSpecDefinitionMethod(t *testing.T) {
|
|
// Initialize test with 256 validators, each slot and each index gets 4 validators.
|
|
validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
Slot: params.BeaconConfig().SlotsPerEpoch,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
// Test for 2 epochs.
|
|
for epoch := uint64(0); epoch < 2; epoch++ {
|
|
state := proto.Clone(state).(*pb.BeaconState)
|
|
assignments, proposers, err := CommitteeAssignments(state, epoch)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for i := uint64(0); int(i) < len(validators); i++ {
|
|
committee, committeeIndex, slot, proposerSlot, err := CommitteeAssignment(state, epoch, i)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(committee, assignments[i].Committee) {
|
|
t.Errorf("Computed different committees for validator %d", i)
|
|
}
|
|
if committeeIndex != assignments[i].CommitteeIndex {
|
|
t.Errorf("Computed different committee index for validator %d", i)
|
|
}
|
|
if slot != assignments[i].AttesterSlot {
|
|
t.Errorf("Computed different attesting slot for validator %d", i)
|
|
}
|
|
if proposerSlot != proposers[i] {
|
|
t.Errorf("Computed different proposing slot for validator %d", i)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCommitteeAssignments_CanRetrieve(t *testing.T) {
|
|
// Initialize test with 256 validators, each slot and each index gets 4 validators.
|
|
validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch)
|
|
for i := 0; i < len(validators); i++ {
|
|
// First 2 epochs only half validators are activated.
|
|
var activationEpoch uint64
|
|
if i >= len(validators)/2 {
|
|
activationEpoch = 3
|
|
}
|
|
validators[i] = ðpb.Validator{
|
|
ActivationEpoch: activationEpoch,
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
Slot: 2 * params.BeaconConfig().SlotsPerEpoch, // epoch 2
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
tests := []struct {
|
|
index uint64
|
|
slot uint64
|
|
committee []uint64
|
|
committeeIndex uint64
|
|
isProposer bool
|
|
proposerSlot uint64
|
|
}{
|
|
{
|
|
index: 0,
|
|
slot: 92,
|
|
committee: []uint64{46, 0},
|
|
committeeIndex: 0,
|
|
isProposer: false,
|
|
},
|
|
{
|
|
index: 1,
|
|
slot: 70,
|
|
committee: []uint64{1, 58},
|
|
committeeIndex: 0,
|
|
isProposer: true,
|
|
proposerSlot: 91,
|
|
},
|
|
{
|
|
index: 11,
|
|
slot: 64,
|
|
committee: []uint64{30, 11},
|
|
committeeIndex: 0,
|
|
isProposer: false,
|
|
}, {
|
|
index: 2,
|
|
slot: 114, // 3rd epoch has more active validators
|
|
committee: []uint64{2, 6, 35, 31},
|
|
committeeIndex: 0,
|
|
isProposer: false,
|
|
},
|
|
}
|
|
|
|
for i, tt := range tests {
|
|
t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
|
|
validatorIndexToCommittee, proposerIndexToSlot, err := CommitteeAssignments(state, SlotToEpoch(tt.slot))
|
|
if err != nil {
|
|
t.Fatalf("failed to determine CommitteeAssignments: %v", err)
|
|
}
|
|
cac := validatorIndexToCommittee[tt.index]
|
|
if cac.CommitteeIndex != tt.committeeIndex {
|
|
t.Errorf("wanted committeeIndex %d, got committeeIndex %d for validator index %d",
|
|
tt.committeeIndex, cac.CommitteeIndex, tt.index)
|
|
}
|
|
if cac.AttesterSlot != tt.slot {
|
|
t.Errorf("wanted slot %d, got slot %d for validator index %d",
|
|
tt.slot, cac.AttesterSlot, tt.index)
|
|
}
|
|
if proposerIndexToSlot[tt.index] != tt.proposerSlot {
|
|
t.Errorf("wanted proposer slot %d, got proposer slot %d for validator index %d",
|
|
tt.proposerSlot, proposerIndexToSlot[tt.index], tt.index)
|
|
}
|
|
if !reflect.DeepEqual(cac.Committee, tt.committee) {
|
|
t.Errorf("wanted committee %v, got committee %v for validator index %d",
|
|
tt.committee, cac.Committee, tt.index)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
|
|
validators := make([]*ethpb.Validator, 2*params.BeaconConfig().SlotsPerEpoch)
|
|
activeRoots := make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
RandaoMixes: activeRoots,
|
|
}
|
|
|
|
tests := []struct {
|
|
attestation *ethpb.Attestation
|
|
stateSlot uint64
|
|
verificationFailure bool
|
|
}{
|
|
{
|
|
attestation: ðpb.Attestation{
|
|
AggregationBits: bitfield.Bitlist{0x05},
|
|
Data: ðpb.AttestationData{
|
|
CommitteeIndex: 5,
|
|
Target: ðpb.Checkpoint{},
|
|
},
|
|
},
|
|
stateSlot: 5,
|
|
},
|
|
{
|
|
|
|
attestation: ðpb.Attestation{
|
|
AggregationBits: bitfield.Bitlist{0x06},
|
|
Data: ðpb.AttestationData{
|
|
CommitteeIndex: 10,
|
|
Target: ðpb.Checkpoint{},
|
|
},
|
|
},
|
|
stateSlot: 10,
|
|
},
|
|
{
|
|
attestation: ðpb.Attestation{
|
|
AggregationBits: bitfield.Bitlist{0x06},
|
|
Data: ðpb.AttestationData{
|
|
CommitteeIndex: 20,
|
|
Target: ðpb.Checkpoint{},
|
|
},
|
|
},
|
|
stateSlot: 20,
|
|
},
|
|
{
|
|
attestation: ðpb.Attestation{
|
|
AggregationBits: bitfield.Bitlist{0x06},
|
|
Data: ðpb.AttestationData{
|
|
CommitteeIndex: 20,
|
|
Target: ðpb.Checkpoint{},
|
|
},
|
|
},
|
|
stateSlot: 20,
|
|
},
|
|
{
|
|
attestation: ðpb.Attestation{
|
|
AggregationBits: bitfield.Bitlist{0xFF, 0xC0, 0x01},
|
|
Data: ðpb.AttestationData{
|
|
CommitteeIndex: 5,
|
|
Target: ðpb.Checkpoint{},
|
|
},
|
|
},
|
|
stateSlot: 5,
|
|
verificationFailure: true,
|
|
},
|
|
{
|
|
attestation: ðpb.Attestation{
|
|
AggregationBits: bitfield.Bitlist{0xFF, 0x01},
|
|
Data: ðpb.AttestationData{
|
|
CommitteeIndex: 20,
|
|
Target: ðpb.Checkpoint{},
|
|
},
|
|
},
|
|
stateSlot: 20,
|
|
verificationFailure: true,
|
|
},
|
|
}
|
|
|
|
for i, tt := range tests {
|
|
state.Slot = tt.stateSlot
|
|
err := VerifyAttestationBitfieldLengths(state, tt.attestation)
|
|
if tt.verificationFailure {
|
|
if err == nil {
|
|
t.Error("verification succeeded when it was supposed to fail")
|
|
}
|
|
continue
|
|
}
|
|
if err != nil {
|
|
t.Errorf("%d Failed to verify bitfield: %v", i, err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestShuffledIndices_ShuffleRightLength(t *testing.T) {
|
|
valiatorCount := 1000
|
|
validators := make([]*ethpb.Validator, valiatorCount)
|
|
indices := make([]uint64, valiatorCount)
|
|
for i := 0; i < valiatorCount; i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
indices[i] = uint64(i)
|
|
}
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
// Test for current epoch
|
|
shuffledIndices, err := ShuffledIndices(state, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(shuffledIndices) != valiatorCount {
|
|
t.Errorf("Incorrect shuffled indices count, wanted: %d, got: %d",
|
|
valiatorCount, len(shuffledIndices))
|
|
}
|
|
if reflect.DeepEqual(indices, shuffledIndices) {
|
|
t.Error("Shuffling did not happen")
|
|
}
|
|
|
|
// Test for next epoch
|
|
shuffledIndices, err = ShuffledIndices(state, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(shuffledIndices) != valiatorCount {
|
|
t.Errorf("Incorrect shuffled indices count, wanted: %d, got: %d",
|
|
valiatorCount, len(shuffledIndices))
|
|
}
|
|
if reflect.DeepEqual(indices, shuffledIndices) {
|
|
t.Error("Shuffling did not happen")
|
|
}
|
|
}
|
|
|
|
func TestUpdateCommitteeCache_CanUpdate(t *testing.T) {
|
|
c := featureconfig.Get()
|
|
c.EnableNewCache = true
|
|
featureconfig.Init(c)
|
|
defer featureconfig.Init(nil)
|
|
|
|
validatorCount := int(params.BeaconConfig().MinGenesisActiveValidatorCount)
|
|
validators := make([]*ethpb.Validator, validatorCount)
|
|
indices := make([]uint64, validatorCount)
|
|
for i := 0; i < validatorCount; i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
indices[i] = uint64(i)
|
|
}
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
if err := UpdateCommitteeCache(state, CurrentEpoch(state)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
epoch := uint64(1)
|
|
idx := uint64(1)
|
|
seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
indices, err = committeeCache.Committee(StartSlot(epoch), seed, idx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(indices) != int(params.BeaconConfig().TargetCommitteeSize) {
|
|
t.Errorf("Did not save correct indices lengths, got %d wanted %d", len(indices), params.BeaconConfig().TargetCommitteeSize)
|
|
}
|
|
}
|
|
|
|
func BenchmarkComputeCommittee300000_WithPreCache(b *testing.B) {
|
|
validators := make([]*ethpb.Validator, 300000)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
epoch := CurrentEpoch(state)
|
|
indices, err := ActiveValidatorIndices(state, epoch)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
index := uint64(3)
|
|
_, err = 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)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkComputeCommittee3000000_WithPreCache(b *testing.B) {
|
|
validators := make([]*ethpb.Validator, 3000000)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
epoch := CurrentEpoch(state)
|
|
indices, err := ActiveValidatorIndices(state, epoch)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
index := uint64(3)
|
|
_, err = 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)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkComputeCommittee128000_WithOutPreCache(b *testing.B) {
|
|
validators := make([]*ethpb.Validator, 128000)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
epoch := CurrentEpoch(state)
|
|
indices, err := ActiveValidatorIndices(state, epoch)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
i := uint64(0)
|
|
index := uint64(0)
|
|
b.ResetTimer()
|
|
for n := 0; n < b.N; n++ {
|
|
i++
|
|
_, err := ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if i < params.BeaconConfig().TargetCommitteeSize {
|
|
index = (index + 1) % params.BeaconConfig().MaxCommitteesPerSlot
|
|
i = 0
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkComputeCommittee1000000_WithOutCache(b *testing.B) {
|
|
validators := make([]*ethpb.Validator, 1000000)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
epoch := CurrentEpoch(state)
|
|
indices, err := ActiveValidatorIndices(state, epoch)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
i := uint64(0)
|
|
index := uint64(0)
|
|
b.ResetTimer()
|
|
for n := 0; n < b.N; n++ {
|
|
i++
|
|
_, err := ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if i < params.BeaconConfig().TargetCommitteeSize {
|
|
index = (index + 1) % params.BeaconConfig().MaxCommitteesPerSlot
|
|
i = 0
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkComputeCommittee4000000_WithOutCache(b *testing.B) {
|
|
validators := make([]*ethpb.Validator, 4000000)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
state := &pb.BeaconState{
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
epoch := CurrentEpoch(state)
|
|
indices, err := ActiveValidatorIndices(state, epoch)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
i := uint64(0)
|
|
index := uint64(0)
|
|
b.ResetTimer()
|
|
for n := 0; n < b.N; n++ {
|
|
i++
|
|
_, err := ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if i < params.BeaconConfig().TargetCommitteeSize {
|
|
index = (index + 1) % params.BeaconConfig().MaxCommitteesPerSlot
|
|
i = 0
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBeaconCommitteeFromState_UpdateCacheForPreviousEpoch(t *testing.T) {
|
|
c := featureconfig.Get()
|
|
c.EnableNewCache = true
|
|
featureconfig.Init(c)
|
|
defer featureconfig.Init(nil)
|
|
|
|
committeeSize := uint64(16)
|
|
validators := make([]*ethpb.Validator, committeeSize*params.BeaconConfig().SlotsPerEpoch)
|
|
for i := 0; i < len(validators); i++ {
|
|
validators[i] = ðpb.Validator{
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
}
|
|
}
|
|
|
|
state := &pb.BeaconState{
|
|
Slot: params.BeaconConfig().SlotsPerEpoch,
|
|
Validators: validators,
|
|
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
|
|
}
|
|
|
|
if _, err := BeaconCommitteeFromState(state, 1 /* previous epoch */, 0); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Verify previous epoch is cached
|
|
seed, err := Seed(state, 0, params.BeaconConfig().DomainBeaconAttester)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
activeIndices, err := committeeCache.ActiveIndices(seed)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if activeIndices == nil {
|
|
t.Error("did not cache active indices")
|
|
}
|
|
}
|