meta

Documentation

Index

• type ActivationExit
• type ActivationQeueue
• type ActiveIndices
• type ActiveValidatorCount
• type AttestationDeltas
• type AttesterStatuses
• type Balance
• type BalanceDeltas
• type BeaconCommittees
• type CommitteeCount
• type CompactCommittees
• type Depositing
• type Deposits
• type EffectiveBalances
• type EffectiveBalancesUpdate
• type EpochAttestations
• type EpochSeed
• type Eth1Voting
• type Exits
• type Finality
• type History
• type HistoryUpdate
• type Justification
• type LatestHeader
• type LatestHeaderUpdate
• type Onboarding
• type Proposers
• type Pubkeys
• type Randao
• type Randomness
• type RegistrySize
• type SlashedIndices
• type Slasher
• type Slashing
• type SlashingHistory
• type Staking
• type ValidatorEpochData
• type Validators
• type Versioning

Types

type ActivationExit

type ActivationExit interface {
	GetChurnLimit(epoch Epoch) uint64
	ExitQueueEnd(epoch Epoch) Epoch
}

type ActivationQeueue

type ActivationQeueue interface {
	ProcessActivationQueue(activationEpoch Epoch, currentEpoch Epoch)
}

type ActiveIndices

type ActiveIndices interface {
	IsActive(index ValidatorIndex, epoch Epoch) bool
	GetActiveValidatorIndices(epoch Epoch) RegistryIndices
	ComputeActiveIndexRoot(epoch Epoch) Root
}

type ActiveValidatorCount

type ActiveValidatorCount interface {
	GetActiveValidatorCount(epoch Epoch) uint64
}

type AttestationDeltas

type AttestationDeltas interface {
	AttestationDeltas() *Deltas
}

type AttesterStatuses

type AttesterStatuses interface {
	GetAttesterStatuses() []AttesterStatus
}

type Balance

type Balance interface {
	GetBalance(index ValidatorIndex) Gwei
	IncreaseBalance(index ValidatorIndex, v Gwei)
	DecreaseBalance(index ValidatorIndex, v Gwei)
}

type BalanceDeltas

type BalanceDeltas interface {
	ApplyDeltas(deltas *Deltas)
}

type BeaconCommittees

type BeaconCommittees interface {
	GetBeaconCommittee(slot Slot, index CommitteeIndex) []ValidatorIndex
}

type CommitteeCount

type CommitteeCount interface {
	GetCommitteeCountAtSlot(slot Slot) uint64
}

type CompactCommittees

type CompactCommittees interface {
	Pubkeys
	EffectiveBalances
	SlashedIndices
	GetCompactCommitteesRoot(epoch Epoch) Root
}

type Depositing

type Depositing interface {
	IncrementDepositIndex()
}

type Deposits

type Deposits interface {
	DepIndex() DepositIndex
	DepCount() DepositIndex
	DepRoot() Root
}

type EffectiveBalances

type EffectiveBalances interface {
	EffectiveBalance(index ValidatorIndex) Gwei
	SumEffectiveBalanceOf(indices []ValidatorIndex) (sum Gwei)
}

type EffectiveBalancesUpdate

type EffectiveBalancesUpdate interface {
	UpdateEffectiveBalances()
}

type EpochAttestations

type EpochAttestations interface {
	RotateEpochAttestations()
}

type EpochSeed

type EpochSeed interface {
	// Retrieve the seed for beacon proposer indices.
	GetSeed(epoch Epoch, domainType BLSDomainType) Root
}

type Eth1Voting

type Eth1Voting interface {
	ResetEth1Votes()
}

type Exits

type Exits interface {
	InitiateValidatorExit(currentEpoch Epoch, index ValidatorIndex)
}

type Finality

type Finality interface {
	Finalized() Checkpoint
	CurrentJustified() Checkpoint
	PreviousJustified() Checkpoint
}

type History

type History interface {
	GetBlockRootAtSlot(slot Slot) Root
	GetBlockRoot(epoch Epoch) Root
}

type HistoryUpdate

type HistoryUpdate interface {
	SetRecentRoots(slot Slot, blockRoot Root, stateRoot Root)
	UpdateStateRoot(root Root)
	UpdateHistoricalRoots()
}

type Justification

type Justification interface {
	Justify(checkpoint Checkpoint)
}

type LatestHeader

type LatestHeader interface {
	// Signing root of latest_block_header
	GetLatestBlockRoot() Root
}

type LatestHeaderUpdate

type LatestHeaderUpdate interface {
	UpdateLatestBlockRoot(stateRoot Root) Root
}

type Onboarding

type Onboarding interface {
	AddNewValidator(pubkey BLSPubkey, withdrawalCreds Root, balance Gwei)
}

type Proposers

type Proposers interface {
	GetBeaconProposerIndex(slot Slot) ValidatorIndex
}

type Pubkeys

type Pubkeys interface {
	Pubkey(index ValidatorIndex) BLSPubkey
	ValidatorIndex(pubkey BLSPubkey) (index ValidatorIndex, exists bool)
}

type Randao

type Randao interface {
	PrepareRandao(epoch Epoch)
}

type Randomness

type Randomness interface {
	GetRandomMix(epoch Epoch) Root
}

type RegistrySize

type RegistrySize interface {
	IsValidIndex(index ValidatorIndex) bool
	ValidatorCount() uint64
}

type SlashedIndices

type SlashedIndices interface {
	IsSlashed(i ValidatorIndex) bool
	FilterUnslashed(indices []ValidatorIndex) []ValidatorIndex
}

type Slasher

type Slasher interface {
	SlashValidator(slashedIndex ValidatorIndex, whistleblowerIndex *ValidatorIndex)
}

type Slashing

type Slashing interface {
	GetIndicesToSlash(withdrawal Epoch) (out []ValidatorIndex)
}

type SlashingHistory

type SlashingHistory interface {
	ResetSlashings(epoch Epoch)
}

type Staking

type Staking interface {
	// Staked = Active effective balance
	GetTotalStake() Gwei
	GetAttestersStake(statuses []AttesterStatus, mask AttesterFlag) Gwei
}

type ValidatorEpochData

type ValidatorEpochData interface {
	WithdrawableEpoch(index ValidatorIndex) Epoch
}

type Validators

type Validators interface {
	Validator(index ValidatorIndex) *validator.Validator
}

type Versioning

type Versioning interface {
	CurrentSlot() Slot
	CurrentEpoch() Epoch
	PreviousEpoch() Epoch
	GetDomain(dom BLSDomainType, messageEpoch Epoch) BLSDomain
}