mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2025-01-05 17:22:18 +00:00
a8e501b3cf
* update deps * update deps * update protos/* * update deps * reset protos * update protos * update shared/params/config * update protos * update /shared * update shared/slotutil and shared/testutil * update beacon-chain/core/helpers * updates beacon-chain/state * update beacon-chain/forkchoice * update beacon-chain/blockchain * update beacon-chain/cache * update beacon-chain/core * update beacon-chain/db * update beacon-chain/node * update beacon-chain/p2p * update beacon-chain/rpc * update beacon-chain/sync * go mod tidy * make sure that beacon-chain build suceeds * go fmt * update e2e tests * update slasher * remove redundant alias * update validator * gazelle * fix build errors in unit tests * go fmt * update deps * update fuzz/BUILD.bazel * fix unit tests * more unit test fixes * fix blockchain UTs * more unit test fixes
286 lines
9.0 KiB
Go
286 lines
9.0 KiB
Go
package beaconv1
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
pbtypes "github.com/gogo/protobuf/types"
|
|
"github.com/prysmaticlabs/eth2-types"
|
|
"github.com/prysmaticlabs/prysm/shared/params"
|
|
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
|
|
"github.com/prysmaticlabs/prysm/shared/testutil/require"
|
|
)
|
|
|
|
func TestGetSpec(t *testing.T) {
|
|
params.SetupTestConfigCleanup(t)
|
|
config := params.BeaconConfig()
|
|
|
|
config.ConfigName = "ConfigName"
|
|
config.MaxCommitteesPerSlot = 1
|
|
config.TargetCommitteeSize = 2
|
|
config.MaxValidatorsPerCommittee = 3
|
|
config.MinPerEpochChurnLimit = 4
|
|
config.ChurnLimitQuotient = 5
|
|
config.ShuffleRoundCount = 6
|
|
config.MinGenesisActiveValidatorCount = 7
|
|
config.MinGenesisTime = 8
|
|
config.HysteresisQuotient = 9
|
|
config.HysteresisDownwardMultiplier = 10
|
|
config.HysteresisUpwardMultiplier = 11
|
|
config.SafeSlotsToUpdateJustified = 12
|
|
config.Eth1FollowDistance = 13
|
|
config.TargetAggregatorsPerCommittee = 14
|
|
config.RandomSubnetsPerValidator = 15
|
|
config.EpochsPerRandomSubnetSubscription = 16
|
|
config.SecondsPerETH1Block = 17
|
|
config.DepositChainID = 18
|
|
config.DepositNetworkID = 19
|
|
config.DepositContractAddress = "DepositContractAddress"
|
|
config.MinDepositAmount = 20
|
|
config.MaxEffectiveBalance = 21
|
|
config.EjectionBalance = 22
|
|
config.EffectiveBalanceIncrement = 23
|
|
config.GenesisForkVersion = []byte("GenesisForkVersion")
|
|
config.BLSWithdrawalPrefixByte = byte('b')
|
|
config.GenesisDelay = 24
|
|
config.SecondsPerSlot = 25
|
|
config.MinAttestationInclusionDelay = 26
|
|
config.SlotsPerEpoch = 27
|
|
config.MinSeedLookahead = 28
|
|
config.MaxSeedLookahead = 29
|
|
config.EpochsPerEth1VotingPeriod = 30
|
|
config.SlotsPerHistoricalRoot = 31
|
|
config.MinValidatorWithdrawabilityDelay = 32
|
|
config.ShardCommitteePeriod = 33
|
|
config.MinEpochsToInactivityPenalty = 34
|
|
config.EpochsPerHistoricalVector = 35
|
|
config.EpochsPerSlashingsVector = 36
|
|
config.HistoricalRootsLimit = 37
|
|
config.ValidatorRegistryLimit = 38
|
|
config.BaseRewardFactor = 39
|
|
config.WhistleBlowerRewardQuotient = 40
|
|
config.ProposerRewardQuotient = 41
|
|
config.InactivityPenaltyQuotient = 42
|
|
config.MinSlashingPenaltyQuotient = 43
|
|
config.ProportionalSlashingMultiplier = 44
|
|
config.MaxProposerSlashings = 45
|
|
config.MaxAttesterSlashings = 46
|
|
config.MaxAttestations = 47
|
|
config.MaxDeposits = 48
|
|
config.MaxVoluntaryExits = 49
|
|
|
|
var dbp [4]byte
|
|
copy(dbp[:], []byte{'0', '0', '0', '1'})
|
|
config.DomainBeaconProposer = dbp
|
|
var dba [4]byte
|
|
copy(dba[:], []byte{'0', '0', '0', '2'})
|
|
config.DomainBeaconAttester = dba
|
|
var dr [4]byte
|
|
copy(dr[:], []byte{'0', '0', '0', '3'})
|
|
config.DomainRandao = dr
|
|
var dd [4]byte
|
|
copy(dd[:], []byte{'0', '0', '0', '4'})
|
|
config.DomainDeposit = dd
|
|
var dve [4]byte
|
|
copy(dve[:], []byte{'0', '0', '0', '5'})
|
|
config.DomainVoluntaryExit = dve
|
|
var dsp [4]byte
|
|
copy(dsp[:], []byte{'0', '0', '0', '6'})
|
|
config.DomainSelectionProof = dsp
|
|
var daap [4]byte
|
|
copy(daap[:], []byte{'0', '0', '0', '7'})
|
|
config.DomainAggregateAndProof = daap
|
|
|
|
params.OverrideBeaconConfig(config)
|
|
|
|
server := &Server{}
|
|
resp, err := server.GetSpec(context.Background(), &pbtypes.Empty{})
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, 60, len(resp.Data))
|
|
for k, v := range resp.Data {
|
|
switch k {
|
|
case "config_name":
|
|
assert.Equal(t, "ConfigName", v)
|
|
case "max_committees_per_slot":
|
|
assert.Equal(t, "1", v)
|
|
case "target_committee_size":
|
|
assert.Equal(t, "2", v)
|
|
case "max_validators_per_committee":
|
|
assert.Equal(t, "3", v)
|
|
case "min_per_epoch_churn_limit":
|
|
assert.Equal(t, "4", v)
|
|
case "churn_limit_quotient":
|
|
assert.Equal(t, "5", v)
|
|
case "shuffle_round_count":
|
|
assert.Equal(t, "6", v)
|
|
case "min_genesis_active_validator_count":
|
|
assert.Equal(t, "7", v)
|
|
case "min_genesis_time":
|
|
assert.Equal(t, "8", v)
|
|
case "hysteresis_quotient":
|
|
assert.Equal(t, "9", v)
|
|
case "hysteresis_downward_multiplier":
|
|
assert.Equal(t, "10", v)
|
|
case "hysteresis_upward_multiplier":
|
|
assert.Equal(t, "11", v)
|
|
case "safe_slots_to_update_justified":
|
|
assert.Equal(t, "12", v)
|
|
case "eth1_follow_distance":
|
|
assert.Equal(t, "13", v)
|
|
case "target_aggregators_per_committee":
|
|
assert.Equal(t, "14", v)
|
|
case "random_subnets_per_validator":
|
|
assert.Equal(t, "15", v)
|
|
case "epochs_per_random_subnet_subscription":
|
|
assert.Equal(t, "16", v)
|
|
case "seconds_per_eth1_block":
|
|
assert.Equal(t, "17", v)
|
|
case "deposit_chain_id":
|
|
assert.Equal(t, "18", v)
|
|
case "deposit_network_id":
|
|
assert.Equal(t, "19", v)
|
|
case "deposit_contract_address":
|
|
assert.Equal(t, "DepositContractAddress", v)
|
|
case "min_deposit_amount":
|
|
assert.Equal(t, "20", v)
|
|
case "max_effective_balance":
|
|
assert.Equal(t, "21", v)
|
|
case "ejection_balance":
|
|
assert.Equal(t, "22", v)
|
|
case "effective_balance_increment":
|
|
assert.Equal(t, "23", v)
|
|
case "genesis_fork_version":
|
|
assert.Equal(t, "0x47656e65736973466f726b56657273696f6e", v)
|
|
case "bls_withdrawal_prefix":
|
|
assert.Equal(t, "0x62", v)
|
|
case "genesis_delay":
|
|
assert.Equal(t, "24", v)
|
|
case "seconds_per_slot":
|
|
assert.Equal(t, "25", v)
|
|
case "min_attestation_inclusion_delay":
|
|
assert.Equal(t, "26", v)
|
|
case "slots_per_epoch":
|
|
assert.Equal(t, "27", v)
|
|
case "min_seed_lookahead":
|
|
assert.Equal(t, "28", v)
|
|
case "max_seed_lookahead":
|
|
assert.Equal(t, "29", v)
|
|
case "epochs_per_eth1_voting_period":
|
|
assert.Equal(t, "30", v)
|
|
case "slots_per_historical_root":
|
|
assert.Equal(t, "31", v)
|
|
case "min_validator_withdrawability_delay":
|
|
assert.Equal(t, "32", v)
|
|
case "shard_committee_period":
|
|
assert.Equal(t, "33", v)
|
|
case "min_epochs_to_inactivity_penalty":
|
|
assert.Equal(t, "34", v)
|
|
case "epochs_per_historical_vector":
|
|
assert.Equal(t, "35", v)
|
|
case "epochs_per_slashings_vector":
|
|
assert.Equal(t, "36", v)
|
|
case "historical_roots_limit":
|
|
assert.Equal(t, "37", v)
|
|
case "validator_registry_limit":
|
|
assert.Equal(t, "38", v)
|
|
case "base_reward_factor":
|
|
assert.Equal(t, "39", v)
|
|
case "whistleblower_reward_quotient":
|
|
assert.Equal(t, "40", v)
|
|
case "proposer_reward_quotient":
|
|
assert.Equal(t, "41", v)
|
|
case "inactivity_penalty_quotient":
|
|
assert.Equal(t, "42", v)
|
|
case "min_slashing_penalty_quotient":
|
|
assert.Equal(t, "43", v)
|
|
case "proportional_slashing_multiplier":
|
|
assert.Equal(t, "44", v)
|
|
case "max_proposer_slashings":
|
|
assert.Equal(t, "45", v)
|
|
case "max_attester_slashings":
|
|
assert.Equal(t, "46", v)
|
|
case "max_attestations":
|
|
assert.Equal(t, "47", v)
|
|
case "max_deposits":
|
|
assert.Equal(t, "48", v)
|
|
case "max_voluntary_exits":
|
|
assert.Equal(t, "49", v)
|
|
case "domain_beacon_proposer":
|
|
assert.Equal(t, "0x30303031", v)
|
|
case "domain_beacon_attester":
|
|
assert.Equal(t, "0x30303032", v)
|
|
case "domain_randao":
|
|
assert.Equal(t, "0x30303033", v)
|
|
case "domain_deposit":
|
|
assert.Equal(t, "0x30303034", v)
|
|
case "domain_voluntary_exit":
|
|
assert.Equal(t, "0x30303035", v)
|
|
case "domain_selection_proof":
|
|
assert.Equal(t, "0x30303036", v)
|
|
case "domain_aggregate_and_proof":
|
|
assert.Equal(t, "0x30303037", v)
|
|
default:
|
|
t.Errorf("Incorrect key: %s", k)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGetDepositContract(t *testing.T) {
|
|
const chainId = 99
|
|
const address = "0x0000000000000000000000000000000000000009"
|
|
params.SetupTestConfigCleanup(t)
|
|
config := params.BeaconConfig()
|
|
config.DepositChainID = chainId
|
|
config.DepositContractAddress = address
|
|
params.OverrideBeaconConfig(config)
|
|
|
|
s := Server{}
|
|
resp, err := s.GetDepositContract(context.Background(), &pbtypes.Empty{})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, uint64(chainId), resp.Data.ChainId)
|
|
assert.Equal(t, address, resp.Data.Address)
|
|
}
|
|
|
|
func TestForkSchedule_Ok(t *testing.T) {
|
|
genesisForkVersion := []byte("Genesis")
|
|
firstForkVersion, firstForkEpoch := []byte("First"), types.Epoch(100)
|
|
secondForkVersion, secondForkEpoch := []byte("Second"), types.Epoch(200)
|
|
thirdForkVersion, thirdForkEpoch := []byte("Third"), types.Epoch(300)
|
|
|
|
params.SetupTestConfigCleanup(t)
|
|
config := params.BeaconConfig()
|
|
config.GenesisForkVersion = genesisForkVersion
|
|
// Create fork schedule adding keys in non-sorted order.
|
|
schedule := make(map[types.Epoch][]byte, 3)
|
|
schedule[secondForkEpoch] = secondForkVersion
|
|
schedule[firstForkEpoch] = firstForkVersion
|
|
schedule[thirdForkEpoch] = thirdForkVersion
|
|
config.ForkVersionSchedule = schedule
|
|
params.OverrideBeaconConfig(config)
|
|
|
|
s := &Server{}
|
|
resp, err := s.GetForkSchedule(context.Background(), &pbtypes.Empty{})
|
|
require.NoError(t, err)
|
|
require.Equal(t, 3, len(resp.Data))
|
|
fork := resp.Data[0]
|
|
assert.DeepEqual(t, genesisForkVersion, fork.PreviousVersion)
|
|
assert.DeepEqual(t, firstForkVersion, fork.CurrentVersion)
|
|
assert.Equal(t, firstForkEpoch, fork.Epoch)
|
|
fork = resp.Data[1]
|
|
assert.DeepEqual(t, firstForkVersion, fork.PreviousVersion)
|
|
assert.DeepEqual(t, secondForkVersion, fork.CurrentVersion)
|
|
assert.Equal(t, secondForkEpoch, fork.Epoch)
|
|
fork = resp.Data[2]
|
|
assert.DeepEqual(t, secondForkVersion, fork.PreviousVersion)
|
|
assert.DeepEqual(t, thirdForkVersion, fork.CurrentVersion)
|
|
assert.Equal(t, thirdForkEpoch, fork.Epoch)
|
|
}
|
|
|
|
func TestForkSchedule_NoForks(t *testing.T) {
|
|
s := &Server{}
|
|
resp, err := s.GetForkSchedule(context.Background(), &pbtypes.Empty{})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 0, len(resp.Data))
|
|
}
|