precompute

Documentation

Overview

Package precompute provides gathering of nicely-structured data important to feed into epoch processing, such as attesting records and balances, for faster computation.

Index

• func AttestationsDelta(state *stateTrie.BeaconState, pBal *Balance, vp []*Validator) ([]uint64, []uint64, error)
• func AttestedCurrentEpoch(s *stateTrie.BeaconState, a *pb.PendingAttestation) (bool, bool, error)
• func AttestedPrevEpoch(s *stateTrie.BeaconState, a *pb.PendingAttestation) (bool, bool, bool, error)
• func New(ctx context.Context, state *stateTrie.BeaconState) ([]*Validator, *Balance, error)
• func ProcessAttestations(ctx context.Context, state *stateTrie.BeaconState, vp []*Validator, ...) ([]*Validator, *Balance, error)
• func ProcessJustificationAndFinalizationPreCompute(state *stateTrie.BeaconState, pBal *Balance) (*stateTrie.BeaconState, error)
• func ProcessRewardsAndPenaltiesPrecompute(state *stateTrie.BeaconState, pBal *Balance, vp []*Validator) (*stateTrie.BeaconState, error)
• func ProcessSlashingsPrecompute(state *stateTrie.BeaconState, pBal *Balance) error
• func ProposersDelta(state *stateTrie.BeaconState, pBal *Balance, vp []*Validator) ([]uint64, error)
• func SameHead(state *stateTrie.BeaconState, a *pb.PendingAttestation) (bool, error)
• func SameTarget(state *stateTrie.BeaconState, a *pb.PendingAttestation, e uint64) (bool, error)
• type Balance
  • func EnsureBalancesLowerBound(bBal *Balance) *Balance
  • func UpdateBalance(vp []*Validator, bBal *Balance) *Balance
• type Validator
  • func UpdateValidator(vp []*Validator, record *Validator, indices []uint64, a *pb.PendingAttestation, ...) []*Validator

Functions

func AttestationsDelta

func AttestationsDelta(state *stateTrie.BeaconState, pBal *Balance, vp []*Validator) ([]uint64, []uint64, error)

AttestationsDelta computes and returns the rewards and penalties differences for individual validators based on the voting records.

func AttestedCurrentEpoch

func AttestedCurrentEpoch(s *stateTrie.BeaconState, a *pb.PendingAttestation) (bool, bool, error)

AttestedCurrentEpoch returns true if attestation `a` attested once in current epoch and/or epoch boundary block.

func AttestedPrevEpoch

func AttestedPrevEpoch(s *stateTrie.BeaconState, a *pb.PendingAttestation) (bool, bool, bool, error)

AttestedPrevEpoch returns true if attestation `a` attested once in previous epoch and epoch boundary block and/or the same head.

func New

func New(ctx context.Context, state *stateTrie.BeaconState) ([]*Validator, *Balance, error)

New gets called at the beginning of process epoch cycle to return pre computed instances of validators attesting records and total balances attested in an epoch.

func ProcessAttestations

func ProcessAttestations(
	ctx context.Context,
	state *stateTrie.BeaconState,
	vp []*Validator,
	pBal *Balance,
) ([]*Validator, *Balance, error)

ProcessAttestations process the attestations in state and update individual validator's pre computes, it also tracks and updates epoch attesting balances.

func ProcessJustificationAndFinalizationPreCompute

func ProcessJustificationAndFinalizationPreCompute(state *stateTrie.BeaconState, pBal *Balance) (*stateTrie.BeaconState, error)

ProcessJustificationAndFinalizationPreCompute processes justification and finalization during epoch processing. This is where a beacon node can justify and finalize a new epoch. Note: this is an optimized version by passing in precomputed total and attesting balances. def process_justification_and_finalization(state: BeaconState) -> None:

if get_current_epoch(state) <= GENESIS_EPOCH + 1:
    return

previous_epoch = get_previous_epoch(state)
current_epoch = get_current_epoch(state)
old_previous_justified_checkpoint = state.previous_justified_checkpoint
old_current_justified_checkpoint = state.current_justified_checkpoint

# Process justifications
state.previous_justified_checkpoint = state.current_justified_checkpoint
state.justification_bits[1:] = state.justification_bits[:-1]
state.justification_bits[0] = 0b0
matching_target_attestations = get_matching_target_attestations(state, previous_epoch)  # Previous epoch
if get_attesting_balance(state, matching_target_attestations) * 3 >= get_total_active_balance(state) * 2:
    state.current_justified_checkpoint = Checkpoint(epoch=previous_epoch,
                                                    root=get_block_root(state, previous_epoch))
    state.justification_bits[1] = 0b1
matching_target_attestations = get_matching_target_attestations(state, current_epoch)  # Current epoch
if get_attesting_balance(state, matching_target_attestations) * 3 >= get_total_active_balance(state) * 2:
    state.current_justified_checkpoint = Checkpoint(epoch=current_epoch,
                                                    root=get_block_root(state, current_epoch))
    state.justification_bits[0] = 0b1

# Process finalizations
bits = state.justification_bits
# The 2nd/3rd/4th most recent epochs are justified, the 2nd using the 4th as source
if all(bits[1:4]) and old_previous_justified_checkpoint.epoch + 3 == current_epoch:
    state.finalized_checkpoint = old_previous_justified_checkpoint
# The 2nd/3rd most recent epochs are justified, the 2nd using the 3rd as source
if all(bits[1:3]) and old_previous_justified_checkpoint.epoch + 2 == current_epoch:
    state.finalized_checkpoint = old_previous_justified_checkpoint
# The 1st/2nd/3rd most recent epochs are justified, the 1st using the 3rd as source
if all(bits[0:3]) and old_current_justified_checkpoint.epoch + 2 == current_epoch:
    state.finalized_checkpoint = old_current_justified_checkpoint
# The 1st/2nd most recent epochs are justified, the 1st using the 2nd as source
if all(bits[0:2]) and old_current_justified_checkpoint.epoch + 1 == current_epoch:
    state.finalized_checkpoint = old_current_justified_checkpoint

func ProcessRewardsAndPenaltiesPrecompute

func ProcessRewardsAndPenaltiesPrecompute(
	state *stateTrie.BeaconState,
	pBal *Balance,
	vp []*Validator,
) (*stateTrie.BeaconState, error)

ProcessRewardsAndPenaltiesPrecompute processes the rewards and penalties of individual validator. This is an optimized version by passing in precomputed validator attesting records and and total epoch balances.

func ProcessSlashingsPrecompute

func ProcessSlashingsPrecompute(state *stateTrie.BeaconState, pBal *Balance) error

ProcessSlashingsPrecompute processes the slashed validators during epoch processing. This is an optimized version by passing in precomputed total epoch balances.

func ProposersDelta

func ProposersDelta(state *stateTrie.BeaconState, pBal *Balance, vp []*Validator) ([]uint64, error)

ProposersDelta computes and returns the rewards and penalties differences for individual validators based on the proposer inclusion records.

func SameHead

func SameHead(state *stateTrie.BeaconState, a *pb.PendingAttestation) (bool, error)

SameHead returns true if attestation `a` attested to the same block by attestation slot in state.

func SameTarget

func SameTarget(state *stateTrie.BeaconState, a *pb.PendingAttestation, e uint64) (bool, error)

SameTarget returns true if attestation `a` attested to the same target block in state.

Types

type Balance

type Balance struct {
	// ActiveCurrentEpoch is the total effective balance of all active validators during current epoch.
	ActiveCurrentEpoch uint64
	// ActivePrevEpoch is the total effective balance of all active validators during prev epoch.
	ActivePrevEpoch uint64
	// CurrentEpochAttested is the total effective balance of all validators who attested during current epoch.
	CurrentEpochAttested uint64
	// CurrentEpochTargetAttested is the total effective balance of all validators who attested
	// for epoch boundary block during current epoch.
	CurrentEpochTargetAttested uint64
	// PrevEpochAttested is the total effective balance of all validators who attested during prev epoch.
	PrevEpochAttested uint64
	// PrevEpochTargetAttested is the total effective balance of all validators who attested
	// for epoch boundary block during prev epoch.
	PrevEpochTargetAttested uint64
	// PrevEpochHeadAttested is the total effective balance of all validators who attested
	// correctly for head block during prev epoch.
	PrevEpochHeadAttested uint64
}

Balance stores the pre computation of the total participated balances for a given epoch Pre computing and storing such record is essential for process epoch optimizations.

func EnsureBalancesLowerBound

func EnsureBalancesLowerBound(bBal *Balance) *Balance

EnsureBalancesLowerBound ensures all the balances such as active current epoch, active previous epoch and more have EffectiveBalanceIncrement(1 eth) as a lower bound.

func UpdateBalance

func UpdateBalance(vp []*Validator, bBal *Balance) *Balance

UpdateBalance updates pre computed balance store.

type Validator

type Validator struct {
	// IsSlashed is true if the validator has been slashed.
	IsSlashed bool
	// IsWithdrawableCurrentEpoch is true if the validator can withdraw current epoch.
	IsWithdrawableCurrentEpoch bool
	// IsActiveCurrentEpoch is true if the validator was active current epoch.
	IsActiveCurrentEpoch bool
	// IsActivePrevEpoch is true if the validator was active prev epoch.
	IsActivePrevEpoch bool
	// IsCurrentEpochAttester is true if the validator attested current epoch.
	IsCurrentEpochAttester bool
	// IsCurrentEpochTargetAttester is true if the validator attested current epoch target.
	IsCurrentEpochTargetAttester bool
	// IsPrevEpochAttester is true if the validator attested previous epoch.
	IsPrevEpochAttester bool
	// IsPrevEpochTargetAttester is true if the validator attested previous epoch target.
	IsPrevEpochTargetAttester bool
	// IsHeadAttester is true if the validator attested head.
	IsPrevEpochHeadAttester bool

	// CurrentEpochEffectiveBalance is how much effective balance this validator validator has current epoch.
	CurrentEpochEffectiveBalance uint64
	// InclusionSlot is the slot of when the attestation gets included in the chain.
	InclusionSlot uint64
	// InclusionDistance is the distance between the assigned slot and this validator's attestation was included in block.
	InclusionDistance uint64
	// ProposerIndex is the index of proposer at slot where this validator's attestation was included.
	ProposerIndex uint64
	// BeforeEpochTransitionBalance is the validator balance prior to epoch transition.
	BeforeEpochTransitionBalance uint64
	// AfterEpochTransitionBalance is the validator balance after epoch transition.
	AfterEpochTransitionBalance uint64
}

Validator stores the pre computation of individual validator's attesting records these records consist of attestation votes, block inclusion record. Pre computing and storing such record is essential for process epoch optimizations.

func UpdateValidator

func UpdateValidator(vp []*Validator, record *Validator, indices []uint64, a *pb.PendingAttestation, aSlot uint64) []*Validator

UpdateValidator updates pre computed validator store.