Struct EvmCacheBuilder 

pub struct EvmCacheBuilder<P> { /* private fields */ }

Fluent builder for EvmCache.

A readable alternative to the positional EvmCache::with_cache constructor. Defaults: latest block, no disk cache, SpecId::CANCUN.

let provider = ProviderBuilder::new()
    .network::<AnyNetwork>()
    .connect_http("https://example-rpc.invalid".parse()?);
let cache = EvmCache::builder(Arc::new(provider))
    .latest_block()
    .spec(SpecId::CANCUN)
    .build()
    .await;

Implementations

impl<P> EvmCacheBuilder<P>

where P: Provider<AnyNetwork> + 'static,

pub fn new(provider: Arc<P>) -> Self

Start a builder over the given provider.

pub fn block(self, block: BlockId) -> Self

Pin simulations and RPC fetches to a specific block.

Use this to fork at a fixed height for reproducible simulation. Without a call to block or latest_block the builder defaults to the latest block at build time.

pub fn latest_block(self) -> Self

Pin to the latest block.

The height is resolved when build fetches the block header, so the cache forks at whatever was latest at construction. Use block instead to pin a fixed, reproducible height.

pub fn spec(self, spec_id: SpecId) -> Self

Set the EVM hardfork spec (must match the chain’s execution layer).

pub fn chain_id(self, chain_id: u64) -> Self

Set the chain ID reported to simulations via the CHAINID opcode.

Recommended. This is the explicit, authoritative way to set the chain ID. If left unset, build infers it from the provider (eth_chainId), falling back to 1 (Ethereum mainnet) only if that query fails. A disk cache_config also carries a chain_id (which additionally namespaces the on-disk cache directory); when both are set, the value passed here wins for the CHAINID opcode, so keep them consistent.

pub fn cache_config(self, cache_config: CacheConfig) -> Self

Enable disk-backed caching with the given configuration.

Supplying a CacheConfig turns on persistence of EVM state, bytecodes, and immutable data under the configured chain directory; the cache is loaded on build and flushed on drop. Omit it for a purely in-memory cache backed solely by RPC.

pub fn shared_memory_capacity(self, capacity: SharedMemoryCapacity) -> Self

Set how much EVM shared memory to pre-allocate per simulation context.

Defaults to SharedMemoryCapacity::Fixed with 64 * 1024 bytes (65,536 bytes). Use Fixed(n) to pin a size, or SharedMemoryCapacity::Auto to size it from the chain state loaded at build time (e.g. a bincode state file supplied via cache_config). See SharedMemoryCapacity for the trade-offs.

pub async fn build(self) -> EvmCache

Build the EvmCache, fetching the pinned block’s header for context.

If a chain ID was not set via chain_id, it is inferred from the provider (eth_chainId); see chain_id for the full resolution order.