Struct PrefetchRegistry 

pub struct PrefetchRegistry { /* private fields */ }

Registry of access lists keyed by phase, persisted across cycles.

On disk, the registry is stored as a crate-specific magic/version envelope followed by a bincode payload. Unknown or legacy unversioned files are treated as cache misses and loaded as an empty registry.

Implementations

impl PrefetchRegistry

pub fn load(path: &Path) -> Self

Load a registry from path (versioned binary format).

Returns Default (an empty registry) on any error — a missing file, an unreadable file, an unrecognized magic/version header, or corrupt contents. These cases are not distinguished by the return value: an incompatible registry is indistinguishable from a fresh start, so it is treated as a cache miss (logged at warn).

pub fn save(&self, path: &Path) -> Result<(), PersistenceError>

Persist the registry to path in versioned binary format, creating parent directories as needed.

Returns an error if the parent directory cannot be created, serialization fails, or the write fails.

pub fn record(&mut self, phase: &str, access_list: StorageAccessList)

Record the aggregated access list for phase, overwriting any access list previously recorded for that phase.

Each call wholesale replaces the phase’s slot set; it does not merge with the prior list. To accumulate per-address lists instead, use record_keyed.

use evm_fork_cache::prefetch_registry::PrefetchRegistry;
use evm_fork_cache::StorageAccessList;
use alloy_primitives::{Address, U256};

let mut registry = PrefetchRegistry::default();
let addr = Address::repeat_byte(0x01);

let mut al = StorageAccessList::default();
al.slots.insert((addr, U256::from(1)));
registry.record("pool_refresh", al);
assert!(registry.phase_slots("pool_refresh").contains(&(addr, U256::from(1))));

// A second record replaces the slot set rather than merging.
let mut al2 = StorageAccessList::default();
al2.slots.insert((addr, U256::from(2)));
registry.record("pool_refresh", al2);
let slots = registry.phase_slots("pool_refresh");
assert_eq!(slots.len(), 1);
assert!(slots.contains(&(addr, U256::from(2))));

pub fn record_keyed( &mut self, phase: &str, key: Address, access_list: StorageAccessList, )

Record the access list for a single key within a keyed phase.

Unlike record, this inserts into the phase’s per-key nested map: other keys already recorded under phase are preserved, and only the entry for key is replaced. Pairs with prefetch_keyed.

pub fn prefetch_phase( &self, phase: &str, cache: &mut EvmCache, ) -> (usize, usize)

Prefetch all slots for an aggregated phase.

Returns (fetched, errors).

pub fn prefetch_keyed( &self, phase: &str, keys: &[Address], cache: &mut EvmCache, exclude: &HashSet<(Address, U256)>, ) -> (usize, usize)

Prefetch slots for specific keys within a keyed phase, excluding slots already warm from a previous prefetch stage.

Pairs with record_keyed.

Returns (fetched, errors).

pub fn phase_slots(&self, phase: &str) -> HashSet<(Address, U256)>

Returns the set of (address, slot) pairs recorded for an aggregated phase, or an empty set if the phase was never recorded.

Typically used to build the exclude set passed to prefetch_keyed so a later stage skips slots a prior aggregated prefetch already warmed.

Trait Implementations

impl Clone for PrefetchRegistry

fn clone(&self) -> PrefetchRegistry

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PrefetchRegistry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PrefetchRegistry

fn default() -> PrefetchRegistry

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PrefetchRegistry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PrefetchRegistry

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.