Struct InvariantExecutor

pub struct InvariantExecutor<'a> {
    pub executor: Executor,
    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

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> InvariantExecutor<'a>

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

Instantiates a fuzzed executor EVM given a testrunner

pub fn invariant_fuzz( &mut self, invariant_contract: InvariantContract<'_>, fuzz_fixtures: &FuzzFixtures, deployed_libs: &[Address], progress: Option<&ProgressBar>, ) -> 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, deployed_libs: &[Address], ) -> Result<(InvariantTest, impl Strategy<Value = BasicTxDetails>)>

Prepares certain structures to execute the invariant tests:

• Invariant Fuzz Test.
• Invariant Strategy

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.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 4400 bytes