Struct InvariantExecutor 

pub struct InvariantExecutor<'a, FEN: FoundryEvmNetwork> {
    pub executor: Executor<FEN>,
    runner: TestRunner,
    config: InvariantConfig,
    setup_contracts: &'a ContractsByAddress,
    project_contracts: &'a ContractsByArtifact,
    artifact_filters: ArtifactFilters,
}

Wrapper around any Executor implementer which provides fuzzing support using [proptest].

After instantiation, calling invariant_fuzz will proceed to hammer the deployed smart contracts with inputs, until it finds a counterexample sequence. The provided [TestRunner] contains all the configuration which can be overridden via environment variables

Fields

executor: Executor<FEN>

runner: TestRunner

Proptest runner.

config: InvariantConfig

The invariant configuration

setup_contracts: &'a ContractsByAddress

Contracts deployed with setUp()

project_contracts: &'a ContractsByArtifact

Contracts that are part of the project but have not been deployed yet. We need the bytecode to identify them from the stateset changes.

artifact_filters: ArtifactFilters

Filters contracts to be fuzzed through their artifact identifiers.

Implementations

impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN>

pub fn new( executor: Executor<FEN>, runner: TestRunner, config: InvariantConfig, setup_contracts: &'a ContractsByAddress, project_contracts: &'a ContractsByArtifact, ) -> Self

Instantiates a fuzzed executor EVM given a testrunner

pub fn config(self) -> InvariantConfig

pub fn invariant_fuzz( &mut self, invariant_contract: InvariantContract<'_>, fuzz_fixtures: &FuzzFixtures, fuzz_state: EvmFuzzState, progress: Option<&ProgressBar>, early_exit: &EarlyExit, ) -> Result<InvariantFuzzTestResult>

Fuzzes any deployed contract and checks any broken invariant at invariant_address.

fn prepare_test( &mut self, invariant_contract: &InvariantContract<'_>, fuzz_fixtures: &FuzzFixtures, fuzz_state: EvmFuzzState, ) -> Result<(InvariantTest<FEN>, WorkerCorpus)>

Prepares certain structures to execute the invariant tests:

• Invariant Fuzz Test.
• Invariant Corpus Manager.

pub fn select_contract_artifacts( &mut self, invariant_address: Address, ) -> Result<()>

Fills the InvariantExecutor with the artifact identifier filters (in path:name string format). They will be used to filter contracts after the setUp, and more importantly, during the runs.

Also excludes any contract without any mutable functions.

Priority:

targetArtifactSelectors > excludeArtifacts > targetArtifacts

fn validate_selected_contract( &mut self, contract: String, selectors: &[FixedBytes<4>], ) -> Result<String>

Makes sure that the contract exists in the project. If so, it returns its artifact identifier.

pub fn select_contracts_and_senders( &self, to: Address, ) -> Result<(SenderFilters, FuzzRunIdentifiedContracts)>

Selects senders and contracts based on the contract methods targetSenders() -> address[], targetContracts() -> address[] and excludeContracts() -> address[].

pub fn target_interfaces( &self, invariant_address: Address, targeted_contracts: &mut TargetedContracts, ) -> Result<()>

Extends the contracts and selectors to fuzz with the addresses and ABIs specified in targetInterfaces() -> (address, string[])[]. Enables targeting of addresses that are not deployed during setUp such as when fuzzing in a forked environment. Also enables targeting of delegate proxies and contracts deployed with create or create2.

pub fn select_selectors( &self, address: Address, targeted_contracts: &mut TargetedContracts, ) -> Result<()>

Selects the functions to fuzz based on the contract method targetSelectors() and targetArtifactSelectors().

fn add_address_with_functions( &self, address: Address, selectors: &[Selector], should_exclude: bool, targeted_contracts: &mut TargetedContracts, ) -> Result<()>

Adds the address and fuzzed or excluded functions to TargetedContracts.

pub fn compute_settings( &mut self, invariant_address: Address, ) -> Result<InvariantSettings>

Computes the current invariant settings for the given invariant contract address.

This extracts the target contracts, selectors, senders, and failure settings that are used to determine if a persisted counterexample is still valid.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.