evaluators

package
v0.0.10 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Feb 7, 2024 License: GPL-3.0 Imports: 53 Imported by: 0

Documentation

Overview

Package evaluators defines functions which can peer into end to end tests to determine if a chain is running as required.

Index

Constants

This section is empty.

Variables

View Source
var APIGatewayV1Alpha1VerifyIntegrity = e2etypes.Evaluator{
	Name:       "api_gateway_v1alpha1_verify_integrity_epoch_%d",
	Policy:     policies.OnEpoch(2),
	Evaluation: apiGatewayV1Alpha1Verify,
}

APIGatewayV1Alpha1VerifyIntegrity of our API gateway for the Prysm v1alpha1 API. This ensures our gRPC HTTP gateway returns and processes the same data _for the same endpoints_ as using a gRPC connection to interact with the API. Running this in end-to-end tests helps us ensure parity between our HTTP gateway for our API and gRPC never breaks. This evaluator checks a few request/response trips for both GET and POST requests.

View Source
var APIMiddlewareVerifyIntegrity = e2etypes.Evaluator{
	Name:       "api_middleware_verify_integrity_epoch_%d",
	Policy:     policies.OnEpoch(helpers.AltairE2EForkEpoch),
	Evaluation: apiMiddlewareVerify,
}

APIMiddlewareVerifyIntegrity tests our API Middleware for the official Ethereum API. This ensures our API Middleware returns good data compared to gRPC.

View Source
var ActivatesDepositedValidators = e2etypes.Evaluator{
	Name:       "processes_deposit_validators_epoch_%d",
	Policy:     policies.BetweenEpochs(depositActivationStartEpoch, depositEndEpoch),
	Evaluation: activatesDepositedValidators,
}

ActivatesDepositedValidators ensures the expected amount of validator deposits are activated into the state.

View Source
var AllNodesHaveSameHead = e2etypes.Evaluator{
	Name:       "all_nodes_have_same_head_%d",
	Policy:     policies.AllEpochs,
	Evaluation: allNodesHaveSameHead,
}

AllNodesHaveSameHead ensures all nodes have the same head epoch. Checks finality and justification as well. Not checking head block root as it may change irregularly for the validator connected nodes.

View Source
var AltairForkTransition = types.Evaluator{
	Name: "altair_fork_transition_%d",
	Policy: func(e primitives.Epoch) bool {
		altair := policies.OnEpoch(helpers.AltairE2EForkEpoch)

		if startingFork == version.Phase0 {
			return altair(e)
		}
		return false
	},
	Evaluation: altairForkOccurs,
}

AltairForkTransition ensures that the Altair hard fork has occurred successfully.

View Source
var BellatrixForkTransition = types.Evaluator{
	Name:       "bellatrix_fork_transition_%d",
	Policy:     policies.OnEpoch(helpers.BellatrixE2EForkEpoch),
	Evaluation: bellatrixForkOccurs,
}

BellatrixForkTransition ensures that the Bellatrix hard fork has occurred successfully.

View Source
var BuilderIsActive = e2etypes.Evaluator{
	Name:       "builder_is_active_at_epoch_%d",
	Policy:     policies.OnwardsNthEpoch(helpers.BellatrixE2EForkEpoch),
	Evaluation: builderActive,
}

BuilderIsActive checks that the builder is indeed producing the respective payloads

View Source
var CapellaForkTransition = types.Evaluator{
	Name:       "capella_fork_transition_%d",
	Policy:     policies.OnEpoch(helpers.CapellaE2EForkEpoch),
	Evaluation: capellaForkOccurs,
}

CapellaForkTransition ensures that the Capella hard fork has occurred successfully.

View Source
var ColdStateCheckpoint = e2etypes.Evaluator{
	Name: "cold_state_assignments_from_epoch_%d",
	Policy: func(currentEpoch primitives.Epoch) bool {
		return currentEpoch == epochToCheck
	},
	Evaluation: checkColdStateCheckpoint,
}

ColdStateCheckpoint checks data from the database using cold state storage.

View Source
var DepositedValidatorsAreActive = e2etypes.Evaluator{
	Name:       "deposited_validators_are_active_epoch_%d",
	Policy:     policies.AfterNthEpoch(depositEndEpoch),
	Evaluation: depositedValidatorsAreActive,
}

DepositedValidatorsAreActive ensures the expected amount of validators are active after their deposits are processed.

View Source
var FeeRecipientIsPresent = types.Evaluator{
	Name:       "fee_recipient_is_present_%d",
	Policy:     policies.AfterNthEpoch(helpers.BellatrixE2EForkEpoch),
	Evaluation: feeRecipientIsPresent,
}
View Source
var FinalizationOccurs = func(epoch primitives.Epoch) types.Evaluator {
	return types.Evaluator{
		Name:       "finalizes_at_epoch_%d",
		Policy:     policies.AfterNthEpoch(epoch),
		Evaluation: finalizationOccurs,
	}
}

FinalizationOccurs is an evaluator to make sure finalization is performing as it should. Requires to be run after at least 4 epochs have passed.

View Source
var FinishedSyncing = e2etypes.Evaluator{
	Name:       "finished_syncing_%d",
	Policy:     policies.AllEpochs,
	Evaluation: finishedSyncing,
}

FinishedSyncing returns whether the beacon node with the given rpc port has finished syncing.

View Source
var HealthzCheck = e2etypes.Evaluator{
	Name:       "healthz_check_epoch_%d",
	Policy:     policies.AfterNthEpoch(0),
	Evaluation: healthzCheck,
}

HealthzCheck pings healthz and errors if it doesn't have the expected OK status.

View Source
var InjectDoubleBlockOnEpoch = func(n primitives.Epoch) e2eTypes.Evaluator {
	return e2eTypes.Evaluator{
		Name:       "inject_double_block_%d",
		Policy:     policies.OnEpoch(n),
		Evaluation: proposeDoubleBlock,
	}
}

InjectDoubleBlockOnEpoch proposes a double block to the beacon node for the slasher to detect.

View Source
var InjectDoubleVoteOnEpoch = func(n primitives.Epoch) e2eTypes.Evaluator {
	return e2eTypes.Evaluator{
		Name:       "inject_double_vote_%d",
		Policy:     policies.OnEpoch(n),
		Evaluation: insertDoubleAttestationIntoPool,
	}
}

InjectDoubleVoteOnEpoch broadcasts a double vote into the beacon node pool for the slasher to detect.

View Source
var MetricsCheck = types.Evaluator{
	Name:       "metrics_check_epoch_%d",
	Policy:     policies.AfterNthEpoch(0),
	Evaluation: metricsTest,
}

MetricsCheck performs a check on metrics to make sure caches are functioning, and overall health is good. Not checking the first epoch so the sample size isn't too small.

View Source
var OptimisticSyncEnabled = types.Evaluator{
	Name:       "optimistic_sync_at_epoch_%d",
	Policy:     policies.AllEpochs,
	Evaluation: optimisticSyncEnabled,
}

OptimisticSyncEnabled checks that the node is in an optimistic state.

View Source
var PeersCheck = types.Evaluator{
	Name:       "peers_check_epoch_%d",
	Policy:     policies.AfterNthEpoch(0),
	Evaluation: peersTest,
}

PeersCheck performs a check on peer data to ensure that any connected peers are not publishing invalid data.

View Source
var PeersConnect = e2etypes.Evaluator{
	Name:       "peers_connect_epoch_%d",
	Policy:     policies.OnEpoch(0),
	Evaluation: peersConnect,
}

PeersConnect checks all beacon nodes and returns whether they are connected to each other as peers.

View Source
var ProcessesDepositsInBlocks = e2etypes.Evaluator{
	Name:       "processes_deposits_in_blocks_epoch_%d",
	Policy:     policies.OnEpoch(depositsInBlockStart),
	Evaluation: processesDepositsInBlocks,
}

ProcessesDepositsInBlocks ensures the expected amount of deposits are accepted into blocks.

View Source
var ProposeVoluntaryExit = e2etypes.Evaluator{
	Name:       "propose_voluntary_exit_epoch_%d",
	Policy:     policies.OnEpoch(exitSubmissionEpoch),
	Evaluation: proposeVoluntaryExit,
}

ProposeVoluntaryExit sends a voluntary exit from randomly selected validator in the genesis set.

View Source
var SlashedValidatorsLoseBalanceAfterEpoch = func(n primitives.Epoch) e2eTypes.Evaluator {
	return e2eTypes.Evaluator{
		Name:       "slashed_validators_lose_valance_epoch_%d",
		Policy:     policies.AfterNthEpoch(n),
		Evaluation: validatorsLoseBalance,
	}
}

SlashedValidatorsLoseBalanceAfterEpoch checks if the validators slashed lose the right balance.

View Source
var SubmitWithdrawal = e2etypes.Evaluator{
	Name:       "submit_withdrawal_epoch_%d",
	Policy:     policies.BetweenEpochs(helpers.CapellaE2EForkEpoch-2, helpers.CapellaE2EForkEpoch+1),
	Evaluation: submitWithdrawal,
}

SubmitWithdrawal sends a withdrawal from a previously exited validator.

View Source
var ValidatorSyncParticipation = types.Evaluator{
	Name:       "validator_sync_participation_%d",
	Policy:     policies.OnwardsNthEpoch(helpers.AltairE2EForkEpoch),
	Evaluation: validatorsSyncParticipation,
}

ValidatorSyncParticipation ensures the expected amount of sync committee participants are active.

View Source
var ValidatorsAreActive = types.Evaluator{
	Name:       "validators_active_epoch_%d",
	Policy:     policies.AllEpochs,
	Evaluation: validatorsAreActive,
}

ValidatorsAreActive ensures the expected amount of validators are active.

View Source
var ValidatorsHaveExited = e2etypes.Evaluator{
	Name:       "voluntary_has_exited_%d",
	Policy:     policies.OnEpoch(8),
	Evaluation: validatorsHaveExited,
}

ValidatorsHaveExited checks the beacon state for the exited validator and ensures its marked as exited.

View Source
var ValidatorsHaveWithdrawn = e2etypes.Evaluator{
	Name: "validator_has_withdrawn_%d",
	Policy: func(currentEpoch primitives.Epoch) bool {

		validWithdrawnEpoch := exitSubmissionEpoch + 1 + params.BeaconConfig().MaxSeedLookahead

		if params.BeaconConfig().ConfigName == params.EndToEndName {
			validWithdrawnEpoch = helpers.CapellaE2EForkEpoch + 1
		}
		requiredPolicy := policies.OnEpoch(validWithdrawnEpoch)
		return requiredPolicy(currentEpoch)
	},
	Evaluation: validatorsAreWithdrawn,
}

ValidatorsHaveWithdrawn checks the beacon state for the withdrawn validator and ensures it has been withdrawn.

View Source
var ValidatorsParticipatingAtEpoch = func(epoch primitives.Epoch) types.Evaluator {
	return types.Evaluator{
		Name:       "validators_participating_epoch_%d",
		Policy:     policies.AfterNthEpoch(epoch),
		Evaluation: validatorsParticipating,
	}
}

ValidatorsParticipatingAtEpoch ensures the expected amount of validators are participating.

View Source
var ValidatorsSlashedAfterEpoch = func(n primitives.Epoch) e2eTypes.Evaluator {
	return e2eTypes.Evaluator{
		Name:       "validators_slashed_epoch_%d",
		Policy:     policies.AfterNthEpoch(n),
		Evaluation: validatorsSlashed,
	}
}

ValidatorsSlashedAfterEpoch ensures the expected amount of validators are slashed.

View Source
var ValidatorsVoteWithTheMajority = e2etypes.Evaluator{
	Name:       "validators_vote_with_the_majority_%d",
	Policy:     policies.AfterNthEpoch(0),
	Evaluation: validatorsVoteWithTheMajority,
}

ValidatorsVoteWithTheMajority verifies whether validator vote for eth1data using the majority algorithm.

View Source
var VerifyBlockGraffiti = e2etypes.Evaluator{
	Name:       "verify_graffiti_in_blocks_epoch_%d",
	Policy:     policies.AfterNthEpoch(0),
	Evaluation: verifyGraffitiInBlocks,
}

VerifyBlockGraffiti ensures the block graffiti is one of the random list.

Functions

This section is empty.

Types

This section is empty.

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL