Documentation ¶
Overview ¶
Package helpers contains helper functions outlined in the eth2 beacon chain spec, such as computing committees, randao, rewards/penalties, and more.
Index ¶
- Constants
- Variables
- func ActivationExitEpoch(epoch uint64) uint64
- func ActiveValidatorCount(state *stateTrie.BeaconState, epoch uint64) (uint64, error)
- func ActiveValidatorIndices(state *stateTrie.BeaconState, epoch uint64) ([]uint64, error)
- func AggregateSignature(attestations []*ethpb.Attestation) (bls.Signature, error)
- func AttestingIndices(bf bitfield.Bitfield, committee []uint64) ([]uint64, error)
- func BeaconCommittee(validatorIndices []uint64, seed [32]byte, slot uint64, committeeIndex uint64) ([]uint64, error)
- func BeaconCommitteeFromState(state *stateTrie.BeaconState, slot uint64, committeeIndex uint64) ([]uint64, error)
- func BeaconProposerIndex(state *stateTrie.BeaconState) (uint64, error)
- func BlockRoot(state *stateTrie.BeaconState, epoch uint64) ([]byte, error)
- func BlockRootAtSlot(state *stateTrie.BeaconState, slot uint64) ([]byte, error)
- func ClearCache()
- func CommitteeAssignments(state *stateTrie.BeaconState, epoch uint64) (map[uint64]*CommitteeAssignmentContainer, map[uint64][]uint64, error)
- func ComputeCommittee(indices []uint64, seed [32]byte, index uint64, count uint64) ([]uint64, error)
- func ComputeDomain(domainType [DomainByteLength]byte, forkVersion []byte, ...) ([]byte, error)
- func ComputeForkDigest(version []byte, genesisValidatorsRoot []byte) ([4]byte, error)
- func ComputeProposerIndex(bState *stateTrie.BeaconState, activeIndices []uint64, seed [32]byte) (uint64, error)
- func ComputeProposerIndexWithValidators(validators []*ethpb.Validator, activeIndices []uint64, seed [32]byte) (uint64, error)
- func ComputeShuffledIndex(index uint64, indexCount uint64, seed [32]byte, shuffle bool) (uint64, error)
- func ComputeSigningRoot(object interface{}, domain []byte) ([32]byte, error)
- func ComputeSubnetForAttestation(activeValCount uint64, att *ethpb.Attestation) uint64
- func ComputeSubnetFromCommitteeAndSlot(activeValCount, comIdx, attSlot uint64) uint64
- func CurrentEpoch(state *stateTrie.BeaconState) uint64
- func DecreaseBalance(state *stateTrie.BeaconState, idx uint64, delta uint64) error
- func DecreaseBalanceWithVal(currBalance uint64, delta uint64) uint64
- func Domain(fork *pb.Fork, epoch uint64, domainType [bls.DomainByteLength]byte, ...) ([]byte, error)
- func IncreaseBalance(state *stateTrie.BeaconState, idx uint64, delta uint64) error
- func IncreaseBalanceWithVal(currBalance uint64, delta uint64) uint64
- func IsActiveValidator(validator *ethpb.Validator, epoch uint64) bool
- func IsActiveValidatorUsingTrie(validator *stateTrie.ReadOnlyValidator, epoch uint64) bool
- func IsAggregated(attestation *ethpb.Attestation) bool
- func IsAggregator(committeeCount uint64, slotSig []byte) (bool, error)
- func IsEligibleForActivation(state *stateTrie.BeaconState, validator *ethpb.Validator) bool
- func IsEligibleForActivationQueue(validator *ethpb.Validator) bool
- func IsEligibleForActivationQueueUsingTrie(validator *stateTrie.ReadOnlyValidator) bool
- func IsEligibleForActivationUsingTrie(state *stateTrie.BeaconState, validator *stateTrie.ReadOnlyValidator) bool
- func IsEpochEnd(slot uint64) bool
- func IsEpochStart(slot uint64) bool
- func IsSlashableValidator(val *ethpb.Validator, epoch uint64) bool
- func IsSlashableValidatorUsingTrie(val *stateTrie.ReadOnlyValidator, epoch uint64) bool
- func NextEpoch(state *stateTrie.BeaconState) uint64
- func PrevEpoch(state *stateTrie.BeaconState) uint64
- func RandaoMix(state *stateTrie.BeaconState, epoch uint64) ([]byte, error)
- func RoundUpToNearestEpoch(slot uint64) uint64
- func Seed(state *stateTrie.BeaconState, epoch uint64, domain [bls.DomainByteLength]byte) ([32]byte, error)
- func ShuffleList(input []uint64, seed [32]byte) ([]uint64, error)
- func ShuffledIndex(index uint64, indexCount uint64, seed [32]byte) (uint64, error)
- func ShuffledIndices(state *stateTrie.BeaconState, epoch uint64) ([]uint64, error)
- func SlotCommitteeCount(activeValidatorCount uint64) uint64
- func SlotSignature(state *stateTrie.BeaconState, slot uint64, privKey bls.SecretKey) (bls.Signature, error)
- func SlotToEpoch(slot uint64) uint64
- func SlotToTime(genesisTimeSec uint64, slot uint64) (time.Time, error)
- func SlotsSince(time time.Time) uint64
- func SlotsSinceEpochStarts(slot uint64) uint64
- func SplitIndices(l []uint64, n uint64) [][]uint64
- func StartSlot(epoch uint64) uint64
- func TotalActiveBalance(state *stateTrie.BeaconState) (uint64, error)
- func TotalBalance(state *stateTrie.BeaconState, indices []uint64) uint64
- func UnShuffledIndex(index uint64, indexCount uint64, seed [32]byte) (uint64, error)
- func UnshuffleList(input []uint64, seed [32]byte) ([]uint64, error)
- func UpdateCommitteeCache(state *stateTrie.BeaconState, epoch uint64) error
- func UpdateProposerIndicesInCache(state *stateTrie.BeaconState, epoch uint64) error
- func ValidatorChurnLimit(activeValidatorCount uint64) (uint64, error)
- func VerifyAttestationBitfieldLengths(state *stateTrie.BeaconState, att *ethpb.Attestation) error
- func VerifyBitfieldLength(bf bitfield.Bitfield, committeeSize uint64) error
- func VerifyBlockHeaderSigningRoot(blkHdr *ethpb.BeaconBlockHeader, pub []byte, signature []byte, domain []byte) error
- func VerifyBlockSigningRoot(blk *ethpb.BeaconBlock, pub []byte, signature []byte, domain []byte) error
- func VerifySigningRoot(obj interface{}, pub []byte, signature []byte, domain []byte) error
- func VerifySlotTime(genesisTime uint64, slot uint64, timeTolerance time.Duration) error
- type CommitteeAssignmentContainer
Constants ¶
const DomainByteLength = 4
DomainByteLength length of domain byte array.
const ForkVersionByteLength = 4
ForkVersionByteLength length of fork version byte array.
Variables ¶
var ErrSigFailedToVerify = errors.New("signature did not verify")
ErrSigFailedToVerify returns when a signature of a block object(ie attestation, slashing, exit... etc) failed to verify.
Functions ¶
func ActivationExitEpoch ¶ added in v0.3.2
ActivationExitEpoch takes in epoch number and returns when the validator is eligible for activation and exit.
Spec pseudocode definition:
def compute_activation_exit_epoch(epoch: Epoch) -> Epoch: """ Return the epoch during which validator activations and exits initiated in ``epoch`` take effect. """ return Epoch(epoch + 1 + MAX_SEED_LOOKAHEAD)
func ActiveValidatorCount ¶
func ActiveValidatorCount(state *stateTrie.BeaconState, epoch uint64) (uint64, error)
ActiveValidatorCount returns the number of active validators in the state at the given epoch.
func ActiveValidatorIndices ¶
func ActiveValidatorIndices(state *stateTrie.BeaconState, epoch uint64) ([]uint64, error)
ActiveValidatorIndices filters out active validators based on validator status and returns their indices in a list.
WARNING: This method allocates a new copy of the validator index set and is considered to be very memory expensive. Avoid using this unless you really need the active validator indices for some specific reason.
Spec pseudocode definition:
def get_active_validator_indices(state: BeaconState, epoch: Epoch) -> Sequence[ValidatorIndex]: """ Return the sequence of active validator indices at ``epoch``. """ return [ValidatorIndex(i) for i, v in enumerate(state.validators) if is_active_validator(v, epoch)]
func AggregateSignature ¶ added in v0.2.5
func AggregateSignature(attestations []*ethpb.Attestation) (bls.Signature, error)
AggregateSignature returns the aggregated signature of the input attestations.
Spec pseudocode definition:
def get_aggregate_signature(attestations: Sequence[Attestation]) -> BLSSignature: signatures = [attestation.signature for attestation in attestations] return bls_aggregate_signatures(signatures)
func AttestingIndices ¶
AttestingIndices returns the attesting participants indices from the attestation data. The committee is provided as an argument rather than a direct implementation from the spec definition. Having the committee as an argument allows for re-use of beacon committees when possible.
Spec pseudocode definition:
def get_attesting_indices(state: BeaconState, data: AttestationData, bits: Bitlist[MAX_VALIDATORS_PER_COMMITTEE]) -> Set[ValidatorIndex]: """ Return the set of attesting indices corresponding to ``data`` and ``bits``. """ committee = get_beacon_committee(state, data.slot, data.index) return set(index for i, index in enumerate(committee) if bits[i])
func BeaconCommittee ¶ added in v0.2.3
func BeaconCommittee(validatorIndices []uint64, seed [32]byte, slot uint64, committeeIndex uint64) ([]uint64, error)
BeaconCommittee returns the crosslink committee of a given slot and committee index. The validator indices and seed are provided as an argument rather than a direct implementation from the spec definition. Having them as an argument allows for cheaper computation run time.
func BeaconCommitteeFromState ¶ added in v0.3.0
func BeaconCommitteeFromState(state *stateTrie.BeaconState, slot uint64, committeeIndex uint64) ([]uint64, error)
BeaconCommitteeFromState returns the crosslink committee of a given slot and committee index. This is a spec implementation where state is used as an argument. In case of state retrieval becomes expensive, consider using BeaconCommittee below.
Spec pseudocode definition:
def get_beacon_committee(state: BeaconState, slot: Slot, index: CommitteeIndex) -> Sequence[ValidatorIndex]: """ Return the beacon committee at ``slot`` for ``index``. """ epoch = compute_epoch_at_slot(slot) committees_per_slot = get_committee_count_per_slot(state, epoch) return compute_committee( indices=get_active_validator_indices(state, epoch), seed=get_seed(state, epoch, DOMAIN_BEACON_ATTESTER), index=(slot % SLOTS_PER_EPOCH) * committees_per_slot + index, count=committees_per_slot * SLOTS_PER_EPOCH, )
func BeaconProposerIndex ¶
func BeaconProposerIndex(state *stateTrie.BeaconState) (uint64, error)
BeaconProposerIndex returns proposer index of a current slot.
Spec pseudocode definition:
def get_beacon_proposer_index(state: BeaconState) -> ValidatorIndex: """ Return the beacon proposer index at the current slot. """ epoch = get_current_epoch(state) seed = hash(get_seed(state, epoch, DOMAIN_BEACON_PROPOSER) + int_to_bytes(state.slot, length=8)) indices = get_active_validator_indices(state, epoch) return compute_proposer_index(state, indices, seed)
func BlockRoot ¶
func BlockRoot(state *stateTrie.BeaconState, epoch uint64) ([]byte, error)
BlockRoot returns the block root stored in the BeaconState for epoch start slot.
Spec pseudocode definition:
def get_block_root(state: BeaconState, epoch: Epoch) -> Hash: """ Return the block root at the start of a recent ``epoch``. """ return get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch))
func BlockRootAtSlot ¶
func BlockRootAtSlot(state *stateTrie.BeaconState, slot uint64) ([]byte, error)
BlockRootAtSlot returns the block root stored in the BeaconState for a recent slot. It returns an error if the requested block root is not within the slot range.
Spec pseudocode definition:
def get_block_root_at_slot(state: BeaconState, slot: Slot) -> Hash: """ Return the block root at a recent ``slot``. """ assert slot < state.slot <= slot + SLOTS_PER_HISTORICAL_ROOT return state.block_roots[slot % SLOTS_PER_HISTORICAL_ROOT]
func CommitteeAssignments ¶ added in v0.3.0
func CommitteeAssignments( state *stateTrie.BeaconState, epoch uint64, ) (map[uint64]*CommitteeAssignmentContainer, map[uint64][]uint64, error)
CommitteeAssignments is a map of validator indices pointing to the appropriate committee assignment for the given epoch.
1. Determine the proposer validator index for each slot. 2. Compute all committees. 3. Determine the attesting slot for each committee. 4. Construct a map of validator indices pointing to the respective committees.
func ComputeCommittee ¶
func ComputeCommittee( indices []uint64, seed [32]byte, index uint64, count uint64, ) ([]uint64, error)
ComputeCommittee returns the requested shuffled committee out of the total committees using validator indices and seed.
Spec pseudocode definition:
def compute_committee(indices: Sequence[ValidatorIndex], seed: Hash, index: uint64, count: uint64) -> Sequence[ValidatorIndex]: """ Return the committee corresponding to ``indices``, ``seed``, ``index``, and committee ``count``. """ start = (len(indices) * index) // count end = (len(indices) * (index + 1)) // count return [indices[compute_shuffled_index(ValidatorIndex(i), len(indices), seed)] for i in range(start, end)
func ComputeDomain ¶ added in v1.0.0
func ComputeDomain(domainType [DomainByteLength]byte, forkVersion []byte, genesisValidatorsRoot []byte) ([]byte, error)
ComputeDomain returns the domain version for BLS private key to sign and verify with a zeroed 4-byte array as the fork version.
def compute_domain(domain_type: DomainType, fork_version: Version=None, genesis_validators_root: Root=None) -> Domain:
""" Return the domain for the ``domain_type`` and ``fork_version``. """ if fork_version is None: fork_version = GENESIS_FORK_VERSION if genesis_validators_root is None: genesis_validators_root = Root() # all bytes zero by default fork_data_root = compute_fork_data_root(fork_version, genesis_validators_root) return Domain(domain_type + fork_data_root[:28])
func ComputeForkDigest ¶ added in v1.0.0
ComputeForkDigest returns the fork for the current version and genesis validator root
Spec pseudocode definition:
def compute_fork_digest(current_version: Version, genesis_validators_root: Root) -> ForkDigest: """ Return the 4-byte fork digest for the ``current_version`` and ``genesis_validators_root``. This is a digest primarily used for domain separation on the p2p layer. 4-bytes suffices for practical separation of forks/chains. """ return ForkDigest(compute_fork_data_root(current_version, genesis_validators_root)[:4])
func ComputeProposerIndex ¶ added in v0.2.3
func ComputeProposerIndex(bState *stateTrie.BeaconState, activeIndices []uint64, seed [32]byte) (uint64, error)
ComputeProposerIndex returns the index sampled by effective balance, which is used to calculate proposer.
This method is more efficient than ComputeProposerIndexWithValidators as it uses the read only validator abstraction to retrieve validator related data. Whereas the other method requires a whole copy of the validator set.
Spec pseudocode definition:
def compute_proposer_index(state: BeaconState, indices: Sequence[ValidatorIndex], seed: Hash) -> ValidatorIndex: """ Return from ``indices`` a random index sampled by effective balance. """ assert len(indices) > 0 MAX_RANDOM_BYTE = 2**8 - 1 i = 0 while True: candidate_index = indices[compute_shuffled_index(ValidatorIndex(i % len(indices)), len(indices), seed)] random_byte = hash(seed + int_to_bytes(i // 32, length=8))[i % 32] effective_balance = state.validators[candidate_index].effective_balance if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte: return ValidatorIndex(candidate_index) i += 1
func ComputeProposerIndexWithValidators ¶
func ComputeProposerIndexWithValidators(validators []*ethpb.Validator, activeIndices []uint64, seed [32]byte) (uint64, error)
ComputeProposerIndexWithValidators returns the index sampled by effective balance, which is used to calculate proposer.
Note: This method signature deviates slightly from the spec recommended definition. The full state object is not required to compute the proposer index.
Spec pseudocode definition:
def compute_proposer_index(state: BeaconState, indices: Sequence[ValidatorIndex], seed: Hash) -> ValidatorIndex: """ Return from ``indices`` a random index sampled by effective balance. """ assert len(indices) > 0 MAX_RANDOM_BYTE = 2**8 - 1 i = 0 while True: candidate_index = indices[compute_shuffled_index(ValidatorIndex(i % len(indices)), len(indices), seed)] random_byte = hash(seed + int_to_bytes(i // 32, length=8))[i % 32] effective_balance = state.validators[candidate_index].effective_balance if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte: return ValidatorIndex(candidate_index) i += 1
Deprecated: Prefer using the beacon state with ComputeProposerIndex to avoid an unnecessary copy of the validator set.
func ComputeShuffledIndex ¶ added in v0.2.3
func ComputeShuffledIndex(index uint64, indexCount uint64, seed [32]byte, shuffle bool) (uint64, error)
ComputeShuffledIndex returns the shuffled validator index corresponding to seed and index count. Spec pseudocode definition:
def compute_shuffled_index(index: ValidatorIndex, index_count: uint64, seed: Hash) -> ValidatorIndex: """ Return the shuffled validator index corresponding to ``seed`` (and ``index_count``). """ assert index < index_count # Swap or not (https://link.springer.com/content/pdf/10.1007%2F978-3-642-32009-5_1.pdf) # See the 'generalized domain' algorithm on page 3 for current_round in range(SHUFFLE_ROUND_COUNT): pivot = bytes_to_int(hash(seed + int_to_bytes(current_round, length=1))[0:8]) % index_count flip = ValidatorIndex((pivot + index_count - index) % index_count) position = max(index, flip) source = hash(seed + int_to_bytes(current_round, length=1) + int_to_bytes(position // 256, length=4)) byte = source[(position % 256) // 8] bit = (byte >> (position % 8)) % 2 index = flip if bit else index return ValidatorIndex(index)
func ComputeSigningRoot ¶ added in v1.0.0
ComputeSigningRoot computes the root of the object by calculating the hash tree root of the signing data with the given domain.
Spec pseudocode definition:
def compute_signing_root(ssz_object: SSZObject, domain: Domain) -> Root: """ Return the signing root for the corresponding signing data. """ return hash_tree_root(SigningData( object_root=hash_tree_root(ssz_object), domain=domain, ))
func ComputeSubnetForAttestation ¶ added in v1.0.0
func ComputeSubnetForAttestation(activeValCount uint64, att *ethpb.Attestation) uint64
ComputeSubnetForAttestation returns the subnet for which the provided attestation will be broadcasted to. This differs from the spec definition by instead passing in the active validators indices in the attestation's given epoch.
Spec pseudocode definition: def compute_subnet_for_attestation(state: BeaconState, attestation: Attestation) -> uint64:
""" Compute the correct subnet for an attestation for Phase 0. Note, this mimics expected Phase 1 behavior where attestations will be mapped to their shard subnet. """ slots_since_epoch_start = attestation.data.slot % SLOTS_PER_EPOCH committees_since_epoch_start = get_committee_count_at_slot(state, attestation.data.slot) * slots_since_epoch_start return (committees_since_epoch_start + attestation.data.index) % ATTESTATION_SUBNET_COUNT
func ComputeSubnetFromCommitteeAndSlot ¶ added in v1.0.0
ComputeSubnetFromCommitteeAndSlot is a flattened version of ComputeSubnetForAttestation where we only pass in the relevant fields from the attestation as function arguments.
Spec pseudocode definition: def compute_subnet_for_attestation(state: BeaconState, attestation: Attestation) -> uint64:
""" Compute the correct subnet for an attestation for Phase 0. Note, this mimics expected Phase 1 behavior where attestations will be mapped to their shard subnet. """ slots_since_epoch_start = attestation.data.slot % SLOTS_PER_EPOCH committees_since_epoch_start = get_committee_count_at_slot(state, attestation.data.slot) * slots_since_epoch_start return (committees_since_epoch_start + attestation.data.index) % ATTESTATION_SUBNET_COUNT
func CurrentEpoch ¶
func CurrentEpoch(state *stateTrie.BeaconState) uint64
CurrentEpoch returns the current epoch number calculated from the slot number stored in beacon state.
Spec pseudocode definition:
def get_current_epoch(state: BeaconState) -> Epoch: """ Return the current epoch. """ return compute_epoch_of_slot(state.slot)
func DecreaseBalance ¶
func DecreaseBalance(state *stateTrie.BeaconState, idx uint64, delta uint64) error
DecreaseBalance decreases validator with the given 'index' balance by 'delta' in Gwei.
Spec pseudocode definition:
def decrease_balance(state: BeaconState, index: ValidatorIndex, delta: Gwei) -> None: """ Decrease the validator balance at index ``index`` by ``delta``, with underflow protection. """ state.balances[index] = 0 if delta > state.balances[index] else state.balances[index] - delta
func DecreaseBalanceWithVal ¶ added in v1.0.0
DecreaseBalanceWithVal decreases validator with the given 'index' balance by 'delta' in Gwei. This method is flattened version of the spec method, taking in the raw balance and returning the post balance.
Spec pseudocode definition:
def decrease_balance(state: BeaconState, index: ValidatorIndex, delta: Gwei) -> None: """ Decrease the validator balance at index ``index`` by ``delta``, with underflow protection. """ state.balances[index] = 0 if delta > state.balances[index] else state.balances[index] - delta
func Domain ¶
func Domain(fork *pb.Fork, epoch uint64, domainType [bls.DomainByteLength]byte, genesisRoot []byte) ([]byte, error)
Domain returns the domain version for BLS private key to sign and verify.
Spec pseudocode definition:
def get_domain(state: BeaconState, domain_type: DomainType, epoch: Epoch=None) -> Domain: """ Return the signature domain (fork version concatenated with domain type) of a message. """ epoch = get_current_epoch(state) if epoch is None else epoch fork_version = state.fork.previous_version if epoch < state.fork.epoch else state.fork.current_version return compute_domain(domain_type, fork_version, state.genesis_validators_root)
func IncreaseBalance ¶
func IncreaseBalance(state *stateTrie.BeaconState, idx uint64, delta uint64) error
IncreaseBalance increases validator with the given 'index' balance by 'delta' in Gwei.
Spec pseudocode definition:
def increase_balance(state: BeaconState, index: ValidatorIndex, delta: Gwei) -> None: """ Increase the validator balance at index ``index`` by ``delta``. """ state.balances[index] += delta
func IncreaseBalanceWithVal ¶ added in v1.0.0
IncreaseBalanceWithVal increases validator with the given 'index' balance by 'delta' in Gwei. This method is flattened version of the spec method, taking in the raw balance and returning the post balance.
Spec pseudocode definition:
def increase_balance(state: BeaconState, index: ValidatorIndex, delta: Gwei) -> None: """ Increase the validator balance at index ``index`` by ``delta``. """ state.balances[index] += delta
func IsActiveValidator ¶
IsActiveValidator returns the boolean value on whether the validator is active or not.
Spec pseudocode definition:
def is_active_validator(validator: Validator, epoch: Epoch) -> bool: """ Check if ``validator`` is active. """ return validator.activation_epoch <= epoch < validator.exit_epoch
func IsActiveValidatorUsingTrie ¶ added in v0.3.2
func IsActiveValidatorUsingTrie(validator *stateTrie.ReadOnlyValidator, epoch uint64) bool
IsActiveValidatorUsingTrie checks if a read only validator is active.
func IsAggregated ¶ added in v0.3.0
func IsAggregated(attestation *ethpb.Attestation) bool
IsAggregated returns true if the attestation is an aggregated attestation, false otherwise.
func IsAggregator ¶ added in v0.2.5
IsAggregator returns true if the signature is from the input validator. The committee count is provided as an argument rather than direct implementation from spec. Having committee count as an argument allows cheaper computation at run time.
Spec pseudocode definition:
def is_aggregator(state: BeaconState, slot: Slot, index: CommitteeIndex, slot_signature: BLSSignature) -> bool: committee = get_beacon_committee(state, slot, index) modulo = max(1, len(committee) // TARGET_AGGREGATORS_PER_COMMITTEE) return bytes_to_int(hash(slot_signature)[0:8]) % modulo == 0
func IsEligibleForActivation ¶ added in v0.3.0
func IsEligibleForActivation(state *stateTrie.BeaconState, validator *ethpb.Validator) bool
IsEligibleForActivation checks if the validator is eligible for activation.
Spec pseudocode definition:
def is_eligible_for_activation(state: BeaconState, validator: Validator) -> bool: """ Check if ``validator`` is eligible for activation. """ return ( # Placement in queue is finalized validator.activation_eligibility_epoch <= state.finalized_checkpoint.epoch # Has not yet been activated and validator.activation_epoch == FAR_FUTURE_EPOCH )
func IsEligibleForActivationQueue ¶ added in v0.3.0
IsEligibleForActivationQueue checks if the validator is eligible to be placed into the activation queue.
Spec pseudocode definition:
def is_eligible_for_activation_queue(validator: Validator) -> bool: """ Check if ``validator`` is eligible to be placed into the activation queue. """ return ( validator.activation_eligibility_epoch == FAR_FUTURE_EPOCH and validator.effective_balance == MAX_EFFECTIVE_BALANCE )
func IsEligibleForActivationQueueUsingTrie ¶ added in v0.3.2
func IsEligibleForActivationQueueUsingTrie(validator *stateTrie.ReadOnlyValidator) bool
IsEligibleForActivationQueueUsingTrie checks if the read-only validator is eligible to be placed into the activation queue.
func IsEligibleForActivationUsingTrie ¶ added in v0.3.2
func IsEligibleForActivationUsingTrie(state *stateTrie.BeaconState, validator *stateTrie.ReadOnlyValidator) bool
IsEligibleForActivationUsingTrie checks if the validator is eligible for activation.
func IsEpochEnd ¶
IsEpochEnd returns true if the given slot number is an epoch ending slot number.
func IsEpochStart ¶
IsEpochStart returns true if the given slot number is an epoch starting slot number.
func IsSlashableValidator ¶
IsSlashableValidator returns the boolean value on whether the validator is slashable or not.
Spec pseudocode definition:
def is_slashable_validator(validator: Validator, epoch: Epoch) -> bool: """ Check if ``validator`` is slashable. """ return (not validator.slashed) and (validator.activation_epoch <= epoch < validator.withdrawable_epoch)
func IsSlashableValidatorUsingTrie ¶ added in v1.0.0
func IsSlashableValidatorUsingTrie(val *stateTrie.ReadOnlyValidator, epoch uint64) bool
IsSlashableValidatorUsingTrie checks if a read only validator is slashable.
func NextEpoch ¶
func NextEpoch(state *stateTrie.BeaconState) uint64
NextEpoch returns the next epoch number calculated from the slot number stored in beacon state.
func PrevEpoch ¶
func PrevEpoch(state *stateTrie.BeaconState) uint64
PrevEpoch returns the previous epoch number calculated from the slot number stored in beacon state. It also checks for underflow condition.
Spec pseudocode definition:
def get_previous_epoch(state: BeaconState) -> Epoch: """` Return the previous epoch (unless the current epoch is ``GENESIS_EPOCH``). """ current_epoch = get_current_epoch(state) return GENESIS_EPOCH if current_epoch == GENESIS_EPOCH else Epoch(current_epoch - 1)
func RandaoMix ¶
func RandaoMix(state *stateTrie.BeaconState, epoch uint64) ([]byte, error)
RandaoMix returns the randao mix (xor'ed seed) of a given slot. It is used to shuffle validators.
Spec pseudocode definition:
def get_randao_mix(state: BeaconState, epoch: Epoch) -> Hash: """ Return the randao mix at a recent ``epoch``. """ return state.randao_mixes[epoch % EPOCHS_PER_HISTORICAL_VECTOR]
func RoundUpToNearestEpoch ¶ added in v0.3.2
RoundUpToNearestEpoch rounds up the provided slot value to the nearest epoch.
func Seed ¶
func Seed(state *stateTrie.BeaconState, epoch uint64, domain [bls.DomainByteLength]byte) ([32]byte, error)
Seed returns the randao seed used for shuffling of a given epoch.
Spec pseudocode definition:
def get_seed(state: BeaconState, epoch: Epoch, domain_type: DomainType) -> Hash: """ Return the seed at ``epoch``. """ mix = get_randao_mix(state, Epoch(epoch + EPOCHS_PER_HISTORICAL_VECTOR - MIN_SEED_LOOKAHEAD - 1)) # Avoid underflow return hash(domain_type + int_to_bytes(epoch, length=8) + mix)
func ShuffleList ¶
ShuffleList returns list of shuffled indexes in a pseudorandom permutation `p` of `0...list_size - 1` with “seed“ as entropy. We utilize 'swap or not' shuffling in this implementation; we are allocating the memory with the seed that stays constant between iterations instead of reallocating it each iteration as in the spec. This implementation is based on the original implementation from protolambda, https://github.com/protolambda/eth2-shuffle
improvements: - seed is always the first 32 bytes of the hash input, we just copy it into the buffer one time. - add round byte to seed and hash that part of the buffer. - split up the for-loop in two: 1. Handle the part from 0 (incl) to pivot (incl). This is mirrored around (pivot / 2). 2. Handle the part from pivot (excl) to N (excl). This is mirrored around ((pivot / 2) + (size/2)). - hash source every 256 iterations. - change byteV every 8 iterations. - we start at the edges, and work back to the mirror point. this makes us process each pear exactly once (instead of unnecessarily twice, like in the spec).
func ShuffledIndex ¶
ShuffledIndex returns `p(index)` in a pseudorandom permutation `p` of `0...list_size - 1` with “seed“ as entropy. We utilize 'swap or not' shuffling in this implementation; we are allocating the memory with the seed that stays constant between iterations instead of reallocating it each iteration as in the spec. This implementation is based on the original implementation from protolambda, https://github.com/protolambda/eth2-shuffle
func ShuffledIndices ¶
func ShuffledIndices(state *stateTrie.BeaconState, epoch uint64) ([]uint64, error)
ShuffledIndices uses input beacon state and returns the shuffled indices of the input epoch, the shuffled indices then can be used to break up into committees.
func SlotCommitteeCount ¶ added in v0.3.0
SlotCommitteeCount returns the number of crosslink committees of a slot. The active validator count is provided as an argument rather than a direct implementation from the spec definition. Having the active validator count as an argument allows for cheaper computation, instead of retrieving head state, one can retrieve the validator count.
Spec pseudocode definition:
def get_committee_count_at_slot(state: BeaconState, slot: Slot) -> uint64: """ Return the number of committees at ``slot``. """ epoch = compute_epoch_at_slot(slot) return max(1, min( MAX_COMMITTEES_PER_SLOT, len(get_active_validator_indices(state, epoch)) // SLOTS_PER_EPOCH // TARGET_COMMITTEE_SIZE, ))
func SlotSignature ¶ added in v0.2.5
func SlotSignature(state *stateTrie.BeaconState, slot uint64, privKey bls.SecretKey) (bls.Signature, error)
SlotSignature returns the signed signature of the hash tree root of input slot.
Spec pseudocode definition:
def get_slot_signature(state: BeaconState, slot: Slot, privkey: int) -> BLSSignature: domain = get_domain(state, DOMAIN_SELECTION_PROOF, compute_epoch_at_slot(slot)) signing_root = compute_signing_root(slot, domain) return bls.Sign(privkey, signing_root)
func SlotToEpoch ¶
SlotToEpoch returns the epoch number of the input slot.
Spec pseudocode definition:
def compute_epoch_of_slot(slot: Slot) -> Epoch: """ Return the epoch number of ``slot``. """ return Epoch(slot // SLOTS_PER_EPOCH)
func SlotToTime ¶ added in v1.0.0
SlotToTime takes the given slot and genesis time to determine the start time of the slot.
func SlotsSince ¶ added in v0.3.0
SlotsSince computes the number of time slots that have occurred since the given timestamp.
func SlotsSinceEpochStarts ¶ added in v0.3.0
SlotsSinceEpochStarts returns number of slots since the start of the epoch.
func SplitIndices ¶
SplitIndices splits a list into n pieces.
func StartSlot ¶
StartSlot returns the first slot number of the current epoch.
Spec pseudocode definition:
def compute_start_slot_at_epoch(epoch: Epoch) -> Slot: """ Return the start slot of ``epoch``. """ return Slot(epoch * SLOTS_PER_EPOCH
func TotalActiveBalance ¶
func TotalActiveBalance(state *stateTrie.BeaconState) (uint64, error)
TotalActiveBalance returns the total amount at stake in Gwei of active validators.
Spec pseudocode definition:
def get_total_active_balance(state: BeaconState) -> Gwei: """ Return the combined effective balance of the active validators. """ return get_total_balance(state, set(get_active_validator_indices(state, get_current_epoch(state))))
func TotalBalance ¶
func TotalBalance(state *stateTrie.BeaconState, indices []uint64) uint64
TotalBalance returns the total amount at stake in Gwei of input validators.
Spec pseudocode definition:
def get_total_balance(state: BeaconState, indices: Set[ValidatorIndex]) -> Gwei: """ Return the combined effective balance of the ``indices``. ``EFFECTIVE_BALANCE_INCREMENT`` Gwei minimum to avoid divisions by zero. """ return Gwei(max(EFFECTIVE_BALANCE_INCREMENT, sum([state.validators[index].effective_balance for index in indices])))
func UnShuffledIndex ¶
UnShuffledIndex returns the inverse of ShuffledIndex. This implementation is based on the original implementation from protolambda, https://github.com/protolambda/eth2-shuffle
func UnshuffleList ¶
UnshuffleList un-shuffles the list by running backwards through the round count.
func UpdateCommitteeCache ¶
func UpdateCommitteeCache(state *stateTrie.BeaconState, epoch uint64) error
UpdateCommitteeCache gets called at the beginning of every epoch to cache the committee shuffled indices list with committee index and epoch number. It caches the shuffled indices for current epoch and next epoch.
func UpdateProposerIndicesInCache ¶ added in v0.3.2
func UpdateProposerIndicesInCache(state *stateTrie.BeaconState, epoch uint64) error
UpdateProposerIndicesInCache updates proposer indices entry of the committee cache.
func ValidatorChurnLimit ¶
ValidatorChurnLimit returns the number of validators that are allowed to enter and exit validator pool for an epoch.
Spec pseudocode definition:
def get_validator_churn_limit(state: BeaconState) -> uint64: """ Return the validator churn limit for the current epoch. """ active_validator_indices = get_active_validator_indices(state, get_current_epoch(state)) return max(MIN_PER_EPOCH_CHURN_LIMIT, len(active_validator_indices) // CHURN_LIMIT_QUOTIENT)
func VerifyAttestationBitfieldLengths ¶
func VerifyAttestationBitfieldLengths(state *stateTrie.BeaconState, att *ethpb.Attestation) error
VerifyAttestationBitfieldLengths verifies that an attestations aggregation bitfields is a valid length matching the size of the committee.
func VerifyBitfieldLength ¶
VerifyBitfieldLength verifies that a bitfield length matches the given committee size.
func VerifyBlockHeaderSigningRoot ¶ added in v1.0.0
func VerifyBlockHeaderSigningRoot(blkHdr *ethpb.BeaconBlockHeader, pub []byte, signature []byte, domain []byte) error
VerifyBlockHeaderSigningRoot verifies the signing root of a block header given it's public key, signature and domain.
func VerifyBlockSigningRoot ¶ added in v1.0.0
func VerifyBlockSigningRoot(blk *ethpb.BeaconBlock, pub []byte, signature []byte, domain []byte) error
VerifyBlockSigningRoot verifies the signing root of a block given it's public key, signature and domain.
func VerifySigningRoot ¶ added in v1.0.0
VerifySigningRoot verifies the signing root of an object given it's public key, signature and domain.
Types ¶
type CommitteeAssignmentContainer ¶ added in v0.3.0
type CommitteeAssignmentContainer struct { Committee []uint64 AttesterSlot uint64 CommitteeIndex uint64 }
CommitteeAssignmentContainer represents a committee, index, and attester slot for a given epoch.