Struct WorkerCorpus 

pub struct WorkerCorpus {

    id: usize,
    in_memory_corpus: Vec<CorpusEntry>,
    history_map: Vec<u8>,
    edge_indices: EdgeIndexMap,
    sancov_history_map: Vec<u8>,
    pub(crate) failed_replays: usize,
    pub(crate) metrics: CorpusMetrics,
    sequence_generator: SequenceGenerator,
    current_mutated_index: Option<usize>,
    config: Arc<FuzzCorpusConfig>,
    worker_sync_enabled: bool,
    new_entry_indices: Vec<usize>,
    initial_export_dirs: Option<Vec<PathBuf>>,
    worker_dir: Option<PathBuf>,
    last_sync_metrics: CorpusMetrics,
    optimization_best_value: Option<I256>,
    optimization_best_sequence: Vec<BasicTxDetails>,
    last_new_edge_at: Option<Instant>,
}

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

edge_indices: EdgeIndexMap

Stable dense EVM edge IDs for this worker’s history map.

sancov_history_map: Vec<u8>

History of binned hitcount of sancov (native Rust) edges seen during fuzzing

failed_replays: usize

Number of failed replays from initial corpus

metrics: CorpusMetrics

Worker Metrics

sequence_generator: SequenceGenerator

Shared transaction-sequence generator.

current_mutated_index: Option<usize>

Identifier of current mutated entry for this worker.

config: Arc<FuzzCorpusConfig>

Config

worker_sync_enabled: bool

Whether this corpus participates in stateless worker synchronization.

new_entry_indices: Vec<usize>

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

initial_export_dirs: Option<Vec<PathBuf>>

Corpus directories the master loaded at startup and still needs to distribute.

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

optimization_best_value: Option<I256>

Optimization mode: the best value found so far (loaded from disk or discovered in-run).

optimization_best_sequence: Vec<BasicTxDetails>

Optimization mode: the call sequence that produced the best value.

last_new_edge_at: Option<Instant>

Monotonic time the worker’s local map last gained a first-time edge; None until then.

Updated wherever the map grows: live fuzzing, startup replay, and cross-worker sync. Tracks local discovery (an edge new to this worker), not globally unique discovery. Kept out of CorpusMetrics since a timestamp is neither additive across workers nor serializable.

Implementations

impl WorkerCorpus

pub fn new_sequence( &mut self, test_runner: &mut TestRunner, ) -> Result<SequencePlan>

Produces the next sequence for either execution mode.

pub fn new<FEN: FoundryEvmNetwork>( id: usize, config: FuzzCorpusConfig, sequence_generator: SequenceGenerator, executor: Option<&Executor<FEN>>, target: ReplayTarget<'_>, ) -> Result<Self>

pub(crate) fn from_seed( id: usize, config: FuzzCorpusConfig, sequence_generator: SequenceGenerator, seed: WorkerCorpusSeed, ) -> Result<Self>

pub fn process_inputs( &mut self, inputs: &[BasicTxDetails], cmp_seq: &[Vec<CmpOperands>], new_coverage: bool, optimization: Option<(I256, Vec<BasicTxDetails>)>, )

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

pub fn process_inputs_for_campaign( &mut self, inputs: &[BasicTxDetails], cmp_seq: &[Vec<CmpOperands>], new_coverage: bool, optimization: Option<(I256, Vec<BasicTxDetails>)>, ) -> Option<CampaignCorpusEntry>

Updates worker-local corpus state and returns any corpus entry to persist after the logical campaign has merged worker outputs.

fn process_inputs_inner( &mut self, inputs: &[BasicTxDetails], cmp_seq: &[Vec<CmpOperands>], new_coverage: bool, optimization: Option<(I256, Vec<BasicTxDetails>)>, persist_now: bool, ) -> Option<CampaignCorpusEntry>

fn insert_corpus_entry( &mut self, corpus: CorpusEntry, insertion_mode: CorpusInsertionMode, dedupe_by_coverage: bool, ) -> Option<CampaignCorpusEntry>

fn push_corpus_entry(&mut self, corpus: CorpusEntry)

pub fn optimization_initial_state(&self) -> (Option<I256>, Vec<BasicTxDetails>)

Returns the previously persisted optimization best value and sequence (if any).

fn persist_optimization_state(&self)

Persists the current optimization best value and sequence to disk.

pub(crate) fn persist_campaign_outputs( config: &FuzzCorpusConfig, entries: impl IntoIterator<Item = CampaignCorpusEntry>, optimization_best: Option<(I256, &[BasicTxDetails])>, )

Persists logical-campaign corpus and optimization outputs after worker results have merged.

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

Collects EVM and sancov coverage from call result and updates metrics.

pub(crate) fn time_since_new_edge(&self) -> Option<Duration>

Time since this worker last gained a first-time edge; None until it has seen one. See WorkerCorpus::last_new_edge_at for the local-vs-global caveat.

pub fn hoist_observed_calls( &mut self, observed: &[ObservedCall], parent_tx: &BasicTxDetails, targeted_contracts: &FuzzRunIdentifiedContracts, insertion_mode: CorpusInsertionMode, ) -> Option<CampaignCorpusEntry>

Converts replayable observed sub-calls into one normal multi-transaction corpus entry.

This captures calls shaped by a handler or another target call and lets the existing corpus machinery mutate, evict, sync, and persist them like any other interesting sequence.

pub fn seed_from_test_traces<FEN: FoundryEvmNetwork>( &mut self, invariant_contract: &InvariantContract<'_>, targeted_contracts: &FuzzRunIdentifiedContracts, executor: &Executor<FEN>, ) -> Result<usize>

Seeds the corpus from sibling zero-input unit tests by replaying them on a clone of the post-setUp executor and keeping the direct replayable calls made by each test.

Returns the number of test-derived corpus entries added.

fn push_observed_sequence( &mut self, tx_seq: Vec<BasicTxDetails>, insertion_mode: CorpusInsertionMode, ) -> Option<CampaignCorpusEntry>

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

Flush the oldest corpus mutated more than configured max mutations unless it is favored or pending synchronization.

fn load_sync_corpus( &self, strict: bool, ) -> 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 push_synced_corpus_entry( &mut self, corpus: CorpusEntry, timestamp: u64, file_name: String, )

Adds a calibrated sync entry to the local corpus and queues it for fan-out on the master.

fn calibrate<FEN: FoundryEvmNetwork>( &mut self, executor: &Executor<FEN>, target: ReplayTarget<'_>, strict: bool, ) -> 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(&mut 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<FEN: FoundryEvmNetwork>( &mut self, num_workers: usize, executor: &Executor<FEN>, target: ReplayTarget<'_>, global_corpus_metrics: &GlobalCorpusMetrics, ) -> Result<()>

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

pub(crate) fn finalize_sync<FEN: FoundryEvmNetwork>( &mut self, executor: &Executor<FEN>, target: ReplayTarget<'_>, coordinator: &CorpusSyncCoordinator, ) -> Result<()>

Performs the ordered final synchronization once every worker has stopped fuzzing.

pub(crate) fn can_replay_tx( tx: &BasicTxDetails, stateless: Option<StatelessReplayTarget<'_>>, 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: 656 bytes