Struct WorkerCorpus 

pub struct WorkerCorpus {

    id: usize,
    in_memory_corpus: Vec<CorpusEntry>,
    history_map: Vec<u8>,
    pub(crate) failed_replays: usize,
    pub(crate) metrics: CorpusMetrics,
    tx_generator: BoxedStrategy<BasicTxDetails>,
    mutation_generator: BoxedStrategy<MutationType>,
    current_mutated: Option<Uuid>,
    config: Arc<FuzzCorpusConfig>,
    new_entry_indices: Vec<usize>,
    last_sync_timestamp: u64,
    worker_dir: Option<PathBuf>,
    last_sync_metrics: CorpusMetrics,
}

Per-worker corpus manager.

Fields

id: usize

Worker Id

in_memory_corpus: Vec<CorpusEntry>

In-memory corpus entries populated from the persisted files and runs administered by this worker.

history_map: Vec<u8>

History of binned hitcount of edges seen during fuzzing

failed_replays: usize

Number of failed replays from initial corpus

metrics: CorpusMetrics

Worker Metrics

tx_generator: BoxedStrategy<BasicTxDetails>

Fuzzed calls generator.

mutation_generator: BoxedStrategy<MutationType>

Call sequence mutation strategy type generator used by stateful fuzzing.

current_mutated: Option<Uuid>

Identifier of current mutated entry for this worker.

config: Arc<FuzzCorpusConfig>

Config

new_entry_indices: Vec<usize>

Indices of new entries added to WorkerCorpus::in_memory_corpus since last sync.

last_sync_timestamp: u64

Last sync timestamp in seconds.

worker_dir: Option<PathBuf>

Worker Dir corpus_dir/worker1/

last_sync_metrics: CorpusMetrics

Metrics at last sync - used to calculate deltas while syncing with global metrics

Implementations

impl WorkerCorpus

pub fn new( id: usize, config: FuzzCorpusConfig, tx_generator: BoxedStrategy<BasicTxDetails>, executor: Option<&Executor>, fuzzed_function: Option<&Function>, fuzzed_contracts: Option<&FuzzRunIdentifiedContracts>, ) -> Result<Self>

pub fn process_inputs(&mut self, inputs: &[BasicTxDetails], new_coverage: bool)

Updates stats for the given call sequence, if new coverage produced. Persists the call sequence (if corpus directory is configured and new coverage) and updates in-memory corpus.

pub fn merge_edge_coverage(&mut self, call_result: &mut RawCallResult) -> bool

Collects coverage from call result and updates metrics.

pub fn new_inputs( &mut self, test_runner: &mut TestRunner, fuzz_state: &EvmFuzzState, targeted_contracts: &FuzzRunIdentifiedContracts, ) -> Result<Vec<BasicTxDetails>>

Generates new call sequence from in memory corpus. Evicts oldest corpus mutated more than configured max mutations value. Used by invariant test campaigns.

pub fn new_input( &mut self, test_runner: &mut TestRunner, fuzz_state: &EvmFuzzState, function: &Function, ) -> Result<Bytes>

Generates a new input from the shared in memory corpus. Evicts oldest corpus mutated more than configured max mutations value. Used by fuzz (stateless) test campaigns.

pub fn new_tx(&self, test_runner: &mut TestRunner) -> Result<BasicTxDetails>

Generates single call from corpus strategy.

pub fn generate_next_input( &mut self, test_runner: &mut TestRunner, sequence: &[BasicTxDetails], discarded: bool, depth: usize, ) -> Result<BasicTxDetails>

Returns the next call to be used in call sequence. If coverage guided fuzzing is not configured or if previous input was discarded then this is a new tx from strategy. If running with coverage guided fuzzing it returns a new call only when sequence does not have enough entries, or randomly. Otherwise, returns the next call from initial sequence.

fn evict_oldest_corpus(&mut self) -> Result<()>

Flush the oldest corpus mutated more than configured max mutations unless they are favored.

fn abi_mutate( &self, tx: &mut BasicTxDetails, function: &Function, test_runner: &mut TestRunner, fuzz_state: &EvmFuzzState, ) -> Result<()>

Mutates calldata of provided tx by abi decoding current values and randomly selecting the inputs to change.

fn load_sync_corpus(&self) -> Result<Vec<(CorpusDirEntry, Vec<BasicTxDetails>)>>

Imports the new corpus entries from the sync directory. These contain tx sequences which are replayed and used to update the history map.

fn calibrate( &mut self, executor: &Executor, fuzzed_function: Option<&Function>, fuzzed_contracts: Option<&FuzzRunIdentifiedContracts>, ) -> Result<()>

Syncs and calibrates the in memory corpus and updates the history_map if new coverage is found from the corpus findings of other workers.

fn export_to_master(&self) -> Result<()>

Exports the new corpus entries to the master worker’s sync dir.

fn export_to_workers(&mut self, num_workers: usize) -> Result<()>

Exports the global corpus to the sync/ directories of all the non-master workers.

pub(crate) fn sync_metrics( &mut self, global_corpus_metrics: &GlobalCorpusMetrics, )

Syncs local metrics with global corpus metrics by calculating and applying deltas.

pub fn sync( &mut self, num_workers: usize, executor: &Executor, fuzzed_function: Option<&Function>, fuzzed_contracts: Option<&FuzzRunIdentifiedContracts>, global_corpus_metrics: &GlobalCorpusMetrics, ) -> Result<()>

Syncs the workers in_memory_corpus and history_map with the findings from other workers.

fn can_replay_tx( tx: &BasicTxDetails, fuzzed_function: Option<&Function>, fuzzed_contracts: Option<&FuzzRunIdentifiedContracts>, ) -> bool

Helper to check if a tx can be replayed.

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: 248 bytes