Documentation
¶
Overview ¶
Package helpers contains helper functions outlined in the Ethereum Beacon Chain spec, such as computing committees, randao, rewards/penalties, and more.
Package helpers contains helper functions outlined in the Ethereum Beacon Chain spec, such as computing committees, randao, rewards/penalties, and more.
Index ¶
- Variables
- func ActivationExitEpoch(epoch types.Epoch) types.Epoch
- func ActiveValidatorCount(ctx context.Context, s state.ReadOnlyBeaconState, epoch types.Epoch) (uint64, error)
- func ActiveValidatorIndices(ctx context.Context, s state.ReadOnlyBeaconState, epoch types.Epoch) ([]types.ValidatorIndex, error)
- func AggregateSignature(attestations []*ethpb.Attestation) (bls.Signature, error)
- func BeaconCommittee(ctx context.Context, validatorIndices []types.ValidatorIndex, seed [32]byte, ...) ([]types.ValidatorIndex, error)
- func BeaconCommitteeFromState(ctx context.Context, state state.ReadOnlyBeaconState, slot types.Slot, ...) ([]types.ValidatorIndex, error)
- func BeaconProposerIndex(ctx context.Context, state state.ReadOnlyBeaconState) (types.ValidatorIndex, error)
- func BlockRoot(state state.ReadOnlyBeaconState, epoch types.Epoch) ([]byte, error)
- func BlockRootAtSlot(state state.ReadOnlyBeaconState, slot types.Slot) ([]byte, error)
- func ClearCache()
- func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch types.Epoch) (map[types.ValidatorIndex]*CommitteeAssignmentContainer, ...)
- func ComputeProposerIndex(bState state.ReadOnlyValidators, activeIndices []types.ValidatorIndex, ...) (types.ValidatorIndex, error)
- func ComputeShuffledIndex(index types.ValidatorIndex, indexCount uint64, seed [32]byte, shuffle bool) (types.ValidatorIndex, error)
- func ComputeSubnetForAttestation(activeValCount uint64, att *ethpb.Attestation) uint64
- func ComputeSubnetFromCommitteeAndSlot(activeValCount uint64, comIdx types.CommitteeIndex, attSlot types.Slot) uint64
- func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconState, ...) (types.Epoch, error)
- func CurrentPeriodSyncSubcommitteeIndices(st state.BeaconState, valIdx types.ValidatorIndex) ([]types.CommitteeIndex, error)
- func DecreaseBalance(state state.BeaconState, idx types.ValidatorIndex, delta uint64) error
- func DecreaseBalanceWithVal(currBalance, delta uint64) uint64
- func FinalityDelay(prevEpoch, finalizedEpoch types.Epoch) types.Epoch
- func IncreaseBalance(state state.BeaconState, idx types.ValidatorIndex, delta uint64) error
- func IncreaseBalanceWithVal(currBalance, delta uint64) (uint64, error)
- func IsActiveValidator(validator *ethpb.Validator, epoch types.Epoch) bool
- func IsActiveValidatorUsingTrie(validator state.ReadOnlyValidator, epoch types.Epoch) bool
- func IsAggregated(attestation *ethpb.Attestation) bool
- func IsAggregator(committeeCount uint64, slotSig []byte) (bool, error)
- func IsCurrentPeriodSyncCommittee(st state.BeaconState, valIdx types.ValidatorIndex) (bool, error)
- func IsEligibleForActivation(state state.ReadOnlyCheckpoint, validator *ethpb.Validator) bool
- func IsEligibleForActivationQueue(validator *ethpb.Validator) bool
- func IsEligibleForActivationQueueUsingTrie(validator state.ReadOnlyValidator) bool
- func IsEligibleForActivationUsingTrie(state state.ReadOnlyCheckpoint, validator state.ReadOnlyValidator) bool
- func IsInInactivityLeak(prevEpoch, finalizedEpoch types.Epoch) bool
- func IsNextPeriodSyncCommittee(st state.BeaconState, valIdx types.ValidatorIndex) (bool, error)
- func IsSlashableValidator(activationEpoch, withdrawableEpoch types.Epoch, slashed bool, ...) bool
- func IsSlashableValidatorUsingTrie(val state.ReadOnlyValidator, epoch types.Epoch) bool
- func IsWithinWeakSubjectivityPeriod(ctx context.Context, currentEpoch types.Epoch, ...) (bool, error)
- func LatestWeakSubjectivityEpoch(ctx context.Context, st state.ReadOnlyBeaconState, ...) (types.Epoch, error)
- func NextPeriodSyncSubcommitteeIndices(st state.BeaconState, valIdx types.ValidatorIndex) ([]types.CommitteeIndex, error)
- func ParseWeakSubjectivityInputString(wsCheckpointString string) (*v1alpha1.Checkpoint, error)
- func RandaoMix(state state.ReadOnlyBeaconState, epoch types.Epoch) ([]byte, error)
- func Seed(state state.ReadOnlyBeaconState, epoch types.Epoch, ...) ([32]byte, error)
- func ShuffleList(input []types.ValidatorIndex, seed [32]byte) ([]types.ValidatorIndex, error)
- func ShuffledIndex(index types.ValidatorIndex, indexCount uint64, seed [32]byte) (types.ValidatorIndex, error)
- func ShuffledIndices(s state.ReadOnlyBeaconState, epoch types.Epoch) ([]types.ValidatorIndex, error)
- func SlotCommitteeCount(activeValidatorCount uint64) uint64
- func SplitIndices(l []uint64, n uint64) [][]uint64
- func StateRootAtSlot(state state.ReadOnlyBeaconState, slot types.Slot) ([]byte, error)
- func TotalActiveBalance(s state.ReadOnlyBeaconState) (uint64, error)
- func TotalBalance(state state.ReadOnlyValidators, indices []types.ValidatorIndex) uint64
- func UnShuffledIndex(index types.ValidatorIndex, indexCount uint64, seed [32]byte) (types.ValidatorIndex, error)
- func UnshuffleList(input []types.ValidatorIndex, seed [32]byte) ([]types.ValidatorIndex, error)
- func UpdateCommitteeCache(ctx context.Context, state state.ReadOnlyBeaconState, epoch types.Epoch) error
- func UpdateGenesisEth1Data(state state.BeaconState, deposits []*ethpb.Deposit, eth1Data *ethpb.Eth1Data) (state.BeaconState, error)
- func UpdateProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaconState) error
- func UpdateSyncCommitteeCache(st state.BeaconState) error
- func ValidateAttestationTime(attSlot types.Slot, genesisTime time.Time, clockDisparity time.Duration) error
- func ValidateNilAttestation(attestation *ethpb.Attestation) error
- func ValidateSlotTargetEpoch(data *ethpb.AttestationData) error
- func ValidatorChurnLimit(activeValidatorCount uint64) (uint64, error)
- func VerifyAttestationBitfieldLengths(ctx context.Context, state state.ReadOnlyBeaconState, att *ethpb.Attestation) error
- func VerifyBitfieldLength(bf bitfield.Bitfield, committeeSize uint64) error
- func VerifyCheckpointEpoch(c *ethpb.Checkpoint, genesis time.Time) bool
- type CommitteeAssignmentContainer
Constants ¶
This section is empty.
Variables ¶
var CommitteeCacheInProgressHit = promauto.NewCounter(prometheus.CounterOpts{
Name: "committee_cache_in_progress_hit",
Help: "The number of committee requests that are present in the cache.",
})
Functions ¶
func ActivationExitEpoch ¶
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(ctx context.Context, s state.ReadOnlyBeaconState, epoch types.Epoch) (uint64, error)
ActiveValidatorCount returns the number of active validators in the state at the given epoch.
func ActiveValidatorIndices ¶
func ActiveValidatorIndices(ctx context.Context, s state.ReadOnlyBeaconState, epoch types.Epoch) ([]types.ValidatorIndex, 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 ¶
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)
func BeaconCommittee ¶
func BeaconCommittee( ctx context.Context, validatorIndices []types.ValidatorIndex, seed [32]byte, slot types.Slot, committeeIndex types.CommitteeIndex, ) ([]types.ValidatorIndex, error)
BeaconCommittee returns the beacon committee of a given slot and committee index. The validator indices and seed are provided as an argument rather than an imported implementation from the spec definition. Having them as an argument allows for cheaper computation run time.
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 BeaconCommitteeFromState ¶
func BeaconCommitteeFromState(ctx context.Context, state state.ReadOnlyBeaconState, slot types.Slot, committeeIndex types.CommitteeIndex) ([]types.ValidatorIndex, 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(ctx context.Context, state state.ReadOnlyBeaconState) (types.ValidatorIndex, 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) + uint_to_bytes(state.slot)) indices = get_active_validator_indices(state, epoch) return compute_proposer_index(state, indices, seed)
func BlockRoot ¶
BlockRoot returns the block root stored in the BeaconState for epoch start slot.
Spec pseudocode definition:
def get_block_root(state: BeaconState, epoch: Epoch) -> Root: """ 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 ¶
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) -> Root: """ 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 ClearCache ¶
func ClearCache()
ClearCache clears the beacon committee cache and sync committee cache.
func CommitteeAssignments ¶
func CommitteeAssignments( ctx context.Context, state state.BeaconState, epoch types.Epoch, ) (map[types.ValidatorIndex]*CommitteeAssignmentContainer, map[types.ValidatorIndex][]types.Slot, 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 ComputeProposerIndex ¶
func ComputeProposerIndex(bState state.ReadOnlyValidators, activeIndices []types.ValidatorIndex, seed [32]byte) (types.ValidatorIndex, error)
ComputeProposerIndex returns the index sampled by effective balance, which is used to calculate proposer.
Spec pseudocode definition:
def compute_proposer_index(state: BeaconState, indices: Sequence[ValidatorIndex], seed: Bytes32) -> ValidatorIndex: """ Return from ``indices`` a random index sampled by effective balance. """ assert len(indices) > 0 MAX_RANDOM_BYTE = 2**8 - 1 i = uint64(0) total = uint64(len(indices)) while True: candidate_index = indices[compute_shuffled_index(i % total, total, seed)] random_byte = hash(seed + uint_to_bytes(uint64(i // 32)))[i % 32] effective_balance = state.validators[candidate_index].effective_balance if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte: return candidate_index i += 1
func ComputeShuffledIndex ¶
func ComputeShuffledIndex(index types.ValidatorIndex, indexCount uint64, seed [32]byte, shuffle bool) (types.ValidatorIndex, error)
ComputeShuffledIndex returns the shuffled validator index corresponding to seed and index count. Spec pseudocode definition:
def compute_shuffled_index(index: uint64, index_count: uint64, seed: Bytes32) -> uint64: """ Return the shuffled 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_uint64(hash(seed + uint_to_bytes(uint8(current_round)))[0:8]) % index_count flip = (pivot + index_count - index) % index_count position = max(index, flip) source = hash( seed + uint_to_bytes(uint8(current_round)) + uint_to_bytes(uint32(position // 256)) ) byte = uint8(source[(position % 256) // 8]) bit = (byte >> (position % 8)) % 2 index = flip if bit else index return index
func ComputeSubnetForAttestation ¶
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(committees_per_slot: uint64, slot: Slot, committee_index: CommitteeIndex) -> uint64:
""" Compute the correct subnet for an attestation for Phase 0. Note, this mimics expected future behavior where attestations will be mapped to their shard subnet. """ slots_since_epoch_start = uint64(slot % SLOTS_PER_EPOCH) committees_since_epoch_start = committees_per_slot * slots_since_epoch_start return uint64((committees_since_epoch_start + committee_index) % ATTESTATION_SUBNET_COUNT)
func ComputeSubnetFromCommitteeAndSlot ¶
func ComputeSubnetFromCommitteeAndSlot(activeValCount uint64, comIdx types.CommitteeIndex, attSlot types.Slot) uint64
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(committees_per_slot: uint64, slot: Slot, committee_index: CommitteeIndex) -> uint64:
""" Compute the correct subnet for an attestation for Phase 0. Note, this mimics expected future behavior where attestations will be mapped to their shard subnet. """ slots_since_epoch_start = uint64(slot % SLOTS_PER_EPOCH) committees_since_epoch_start = committees_per_slot * slots_since_epoch_start return uint64((committees_since_epoch_start + committee_index) % ATTESTATION_SUBNET_COUNT)
func ComputeWeakSubjectivityPeriod ¶
func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconState, cfg *params.BeaconChainConfig) (types.Epoch, error)
ComputeWeakSubjectivityPeriod returns weak subjectivity period for the active validator count and finalized epoch.
Reference spec implementation: https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/weak-subjectivity.md#calculating-the-weak-subjectivity-period
def compute_weak_subjectivity_period(state: BeaconState) -> uint64:
""" Returns the weak subjectivity period for the current ``state``. This computation takes into account the effect of: - validator set churn (bounded by ``get_validator_churn_limit()`` per epoch), and - validator balance top-ups (bounded by ``MAX_DEPOSITS * SLOTS_PER_EPOCH`` per epoch). A detailed calculation can be found at: https://github.com/runtimeverification/beacon-chain-verification/blob/master/weak-subjectivity/weak-subjectivity-analysis.pdf """ ws_period = MIN_VALIDATOR_WITHDRAWABILITY_DELAY N = len(get_active_validator_indices(state, get_current_epoch(state))) t = get_total_active_balance(state) // N // ETH_TO_GWEI T = MAX_EFFECTIVE_BALANCE // ETH_TO_GWEI delta = get_validator_churn_limit(state) Delta = MAX_DEPOSITS * SLOTS_PER_EPOCH D = SAFETY_DECAY if T * (200 + 3 * D) < t * (200 + 12 * D): epochs_for_validator_set_churn = ( N * (t * (200 + 12 * D) - T * (200 + 3 * D)) // (600 * delta * (2 * t + T)) ) epochs_for_balance_top_ups = ( N * (200 + 3 * D) // (600 * Delta) ) ws_period += max(epochs_for_validator_set_churn, epochs_for_balance_top_ups) else: ws_period += ( 3 * N * D * t // (200 * Delta * (T - t)) ) return ws_period
func CurrentPeriodSyncSubcommitteeIndices ¶
func CurrentPeriodSyncSubcommitteeIndices( st state.BeaconState, valIdx types.ValidatorIndex, ) ([]types.CommitteeIndex, error)
CurrentPeriodSyncSubcommitteeIndices returns the subcommittee indices of the current period sync committee for input validator.
func DecreaseBalance ¶
func DecreaseBalance(state state.BeaconState, idx types.ValidatorIndex, 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 ¶
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 FinalityDelay ¶
FinalityDelay returns the finality delay using the beacon state.
Spec code: def get_finality_delay(state: BeaconState) -> uint64:
return get_previous_epoch(state) - state.finalized_checkpoint.epoch
func IncreaseBalance ¶
func IncreaseBalance(state state.BeaconState, idx types.ValidatorIndex, 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 ¶
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 ¶
func IsActiveValidatorUsingTrie(validator state.ReadOnlyValidator, epoch types.Epoch) bool
IsActiveValidatorUsingTrie checks if a read only validator is active.
func IsAggregated ¶
func IsAggregated(attestation *ethpb.Attestation) bool
IsAggregated returns true if the attestation is an aggregated attestation, false otherwise.
func IsAggregator ¶
IsAggregator returns true if the signature is from the input validator. The committee count is provided as an argument rather than imported 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_uint64(hash(slot_signature)[0:8]) % modulo == 0
func IsCurrentPeriodSyncCommittee ¶
func IsCurrentPeriodSyncCommittee( st state.BeaconState, valIdx types.ValidatorIndex, ) (bool, error)
IsCurrentPeriodSyncCommittee returns true if the input validator index belongs in the current period sync committee along with the sync committee root. 1. Checks if the public key exists in the sync committee cache 2. If 1 fails, checks if the public key exists in the input current sync committee object
func IsEligibleForActivation ¶
func IsEligibleForActivation(state state.ReadOnlyCheckpoint, 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 ¶
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 ¶
func IsEligibleForActivationQueueUsingTrie(validator state.ReadOnlyValidator) bool
IsEligibleForActivationQueueUsingTrie checks if the read-only validator is eligible to be placed into the activation queue.
func IsEligibleForActivationUsingTrie ¶
func IsEligibleForActivationUsingTrie(state state.ReadOnlyCheckpoint, validator state.ReadOnlyValidator) bool
IsEligibleForActivationUsingTrie checks if the validator is eligible for activation.
func IsInInactivityLeak ¶
IsInInactivityLeak returns true if the state is experiencing inactivity leak.
Spec code: def is_in_inactivity_leak(state: BeaconState) -> bool:
return get_finality_delay(state) > MIN_EPOCHS_TO_INACTIVITY_PENALTY
func IsNextPeriodSyncCommittee ¶
func IsNextPeriodSyncCommittee( st state.BeaconState, valIdx types.ValidatorIndex, ) (bool, error)
IsNextPeriodSyncCommittee returns true if the input validator index belongs in the next period sync committee along with the sync period boundary root. 1. Checks if the public key exists in the sync committee cache 2. If 1 fails, checks if the public key exists in the input next sync committee object
func IsSlashableValidator ¶
func IsSlashableValidator(activationEpoch, withdrawableEpoch types.Epoch, slashed bool, epoch types.Epoch) bool
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 ¶
func IsSlashableValidatorUsingTrie(val state.ReadOnlyValidator, epoch types.Epoch) bool
IsSlashableValidatorUsingTrie checks if a read only validator is slashable.
func IsWithinWeakSubjectivityPeriod ¶
func IsWithinWeakSubjectivityPeriod( ctx context.Context, currentEpoch types.Epoch, wsState state.ReadOnlyBeaconState, wsStateRoot [fieldparams.RootLength]byte, wsEpoch types.Epoch, cfg *params.BeaconChainConfig) (bool, error)
IsWithinWeakSubjectivityPeriod verifies if a given weak subjectivity checkpoint is not stale i.e. the current node is so far beyond, that a given state and checkpoint are not for the latest weak subjectivity point. Provided checkpoint still can be used to double-check that node's block root at a given epoch matches that of the checkpoint.
Reference implementation: https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/weak-subjectivity.md#checking-for-stale-weak-subjectivity-checkpoint
def is_within_weak_subjectivity_period(store: Store, ws_state: BeaconState, ws_checkpoint: Checkpoint) -> bool:
# Clients may choose to validate the input state against the input Weak Subjectivity Checkpoint assert ws_state.latest_block_header.state_root == ws_checkpoint.root assert compute_epoch_at_slot(ws_state.slot) == ws_checkpoint.epoch ws_period = compute_weak_subjectivity_period(ws_state) ws_state_epoch = compute_epoch_at_slot(ws_state.slot) current_epoch = compute_epoch_at_slot(get_current_slot(store)) return current_epoch <= ws_state_epoch + ws_period
func LatestWeakSubjectivityEpoch ¶
func LatestWeakSubjectivityEpoch(ctx context.Context, st state.ReadOnlyBeaconState, cfg *params.BeaconChainConfig) (types.Epoch, error)
LatestWeakSubjectivityEpoch returns epoch of the most recent weak subjectivity checkpoint known to a node.
Within the weak subjectivity period, if two conflicting blocks are finalized, 1/3 - D (D := safety decay) of validators will get slashed. Therefore, it is safe to assume that any finalized checkpoint within that period is protected by this safety margin.
func NextPeriodSyncSubcommitteeIndices ¶
func NextPeriodSyncSubcommitteeIndices( st state.BeaconState, valIdx types.ValidatorIndex, ) ([]types.CommitteeIndex, error)
NextPeriodSyncSubcommitteeIndices returns the subcommittee indices of the next period sync committee for input validator.
func ParseWeakSubjectivityInputString ¶
func ParseWeakSubjectivityInputString(wsCheckpointString string) (*v1alpha1.Checkpoint, error)
ParseWeakSubjectivityInputString parses "blocks_root:epoch_number" string into a checkpoint.
func RandaoMix ¶
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) -> Bytes32: """ Return the randao mix at a recent ``epoch``. """ return state.randao_mixes[epoch % EPOCHS_PER_HISTORICAL_VECTOR]
func Seed ¶
func Seed(state state.ReadOnlyBeaconState, epoch types.Epoch, 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) -> Bytes32: """ 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 + uint_to_bytes(epoch) + mix)
func ShuffleList ¶
func ShuffleList(input []types.ValidatorIndex, seed [32]byte) ([]types.ValidatorIndex, error)
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 ¶
func ShuffledIndex(index types.ValidatorIndex, indexCount uint64, seed [32]byte) (types.ValidatorIndex, error)
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(s state.ReadOnlyBeaconState, epoch types.Epoch) ([]types.ValidatorIndex, 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 ¶
SlotCommitteeCount returns the number of beacon committees of a slot. The active validator count is provided as an argument rather than an imported 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_per_slot(state: BeaconState, epoch: Epoch) -> uint64: """ Return the number of committees in each slot for the given ``epoch``. """ return max(uint64(1), min( MAX_COMMITTEES_PER_SLOT, uint64(len(get_active_validator_indices(state, epoch))) // SLOTS_PER_EPOCH // TARGET_COMMITTEE_SIZE, ))
func SplitIndices ¶
SplitIndices splits a list into n pieces.
func StateRootAtSlot ¶
StateRootAtSlot returns the cached state root at that particular slot. If no state root has been cached it will return a zero-hash.
func TotalActiveBalance ¶
func TotalActiveBalance(s state.ReadOnlyBeaconState) (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. Note: ``get_total_balance`` returns ``EFFECTIVE_BALANCE_INCREMENT`` Gwei minimum to avoid divisions by zero. """ return get_total_balance(state, set(get_active_validator_indices(state, get_current_epoch(state))))
func TotalBalance ¶
func TotalBalance(state state.ReadOnlyValidators, indices []types.ValidatorIndex) 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. Math safe up to ~10B ETH, afterwhich this overflows uint64. """ return Gwei(max(EFFECTIVE_BALANCE_INCREMENT, sum([state.validators[index].effective_balance for index in indices])))
func UnShuffledIndex ¶
func UnShuffledIndex(index types.ValidatorIndex, indexCount uint64, seed [32]byte) (types.ValidatorIndex, error)
UnShuffledIndex returns the inverse of ShuffledIndex. This implementation is based on the original implementation from protolambda, https://github.com/protolambda/eth2-shuffle
func UnshuffleList ¶
func UnshuffleList(input []types.ValidatorIndex, seed [32]byte) ([]types.ValidatorIndex, error)
UnshuffleList un-shuffles the list by running backwards through the round count.
func UpdateCommitteeCache ¶
func UpdateCommitteeCache(ctx context.Context, state state.ReadOnlyBeaconState, epoch types.Epoch) 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 UpdateGenesisEth1Data ¶
func UpdateGenesisEth1Data(state state.BeaconState, deposits []*ethpb.Deposit, eth1Data *ethpb.Eth1Data) (state.BeaconState, error)
UpdateGenesisEth1Data updates eth1 data for genesis state.
func UpdateProposerIndicesInCache ¶
func UpdateProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaconState) error
UpdateProposerIndicesInCache updates proposer indices entry of the committee cache.
func UpdateSyncCommitteeCache ¶
func UpdateSyncCommitteeCache(st state.BeaconState) error
UpdateSyncCommitteeCache updates sync committee cache. It uses `state`'s latest block header root as key. To avoid misuse, it disallows block header with state root zeroed out.
func ValidateAttestationTime ¶
func ValidateAttestationTime(attSlot types.Slot, genesisTime time.Time, clockDisparity time.Duration) error
ValidateAttestationTime Validates that the incoming attestation is in the desired time range. An attestation is valid only if received within the last ATTESTATION_PROPAGATION_SLOT_RANGE slots.
Example:
ATTESTATION_PROPAGATION_SLOT_RANGE = 5 clockDisparity = 24 seconds current_slot = 100 invalid_attestation_slot = 92 invalid_attestation_slot = 103 valid_attestation_slot = 98 valid_attestation_slot = 101
In the attestation must be within the range of 95 to 102 in the example above.
func ValidateNilAttestation ¶
func ValidateNilAttestation(attestation *ethpb.Attestation) error
ValidateNilAttestation checks if any composite field of input attestation is nil. Access to these nil fields will result in run time panic, it is recommended to run these checks as first line of defense.
func ValidateSlotTargetEpoch ¶
func ValidateSlotTargetEpoch(data *ethpb.AttestationData) error
ValidateSlotTargetEpoch checks if attestation data's epoch matches target checkpoint's epoch. It is recommended to run `ValidateNilAttestation` first to ensure `data.Target` can't be nil.
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, uint64(len(active_validator_indices)) // CHURN_LIMIT_QUOTIENT)
func VerifyAttestationBitfieldLengths ¶
func VerifyAttestationBitfieldLengths(ctx context.Context, state state.ReadOnlyBeaconState, 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 VerifyCheckpointEpoch ¶
func VerifyCheckpointEpoch(c *ethpb.Checkpoint, genesis time.Time) bool
VerifyCheckpointEpoch is within current epoch and previous epoch with respect to current time. Returns true if it's within, false if it's not.
Types ¶
type CommitteeAssignmentContainer ¶
type CommitteeAssignmentContainer struct { Committee []types.ValidatorIndex AttesterSlot types.Slot CommitteeIndex types.CommitteeIndex }
CommitteeAssignmentContainer represents a committee list, committee index, and to be attested slot for a given epoch.