Struct EvmOpts 

pub struct EvmOpts {

    pub env: Env,
    pub fork_url: Option<String>,
    pub fork_block_number: Option<u64>,
    pub fork_retries: Option<u32>,
    pub fork_retry_backoff: Option<u64>,
    pub fork_headers: Option<Vec<String>>,
    pub rpc_jwt: Option<String>,
    pub rpc_headers: Option<Vec<String>>,
    pub rpc_timeout: Option<u64>,
    pub rpc_accept_invalid_certs: bool,
    pub rpc_no_proxy: bool,
    pub compute_units_per_second: Option<u64>,
    pub no_rpc_rate_limit: bool,
    pub no_storage_caching: bool,
    pub initial_balance: U256,
    pub sender: Address,
    pub ffi: bool,
    pub always_use_create_2_factory: bool,
    pub verbosity: u8,
    pub memory_limit: u64,
    pub isolate: bool,
    pub disable_block_gas_limit: bool,
    pub enable_tx_gas_limit: bool,
    pub networks: NetworkConfigs,
    pub create2_deployer: Address,
    pub fork_endpoint: Option<ForkEndpointIdentity>,
    pub expected_fork_endpoint: Option<ForkEndpointIdentity>,
    pub fork_network_is_inferred: bool,
    pub fork_chain_id_is_inferred: bool,
    pub fork_block_number_is_inferred: bool,
}

Fields

env: Env

The EVM environment configuration.

fork_url: Option<String>

Fetch state over a remote instead of starting from empty state.

fork_block_number: Option<u64>

Pins the block number for the state fork.

fork_retries: Option<u32>

The number of retries.

fork_retry_backoff: Option<u64>

Initial retry backoff.

fork_headers: Option<Vec<String>>

Headers to use with fork_url

rpc_jwt: Option<String>

JWT secret to use with the configured RPC endpoint.

rpc_headers: Option<Vec<String>>

Headers to use with the configured RPC endpoint.

rpc_timeout: Option<u64>

Request timeout to use with the configured RPC endpoint.

rpc_accept_invalid_certs: bool

Whether to accept invalid certificates from the configured RPC endpoint.

rpc_no_proxy: bool

Whether to disable automatic proxy detection for the configured RPC endpoint.

compute_units_per_second: Option<u64>

The available compute units per second.

See also https://docs.alchemy.com/reference/compute-units#what-are-cups-compute-units-per-second

no_rpc_rate_limit: bool

Disables RPC rate limiting entirely.

no_storage_caching: bool

Disables storage caching entirely.

initial_balance: U256

The initial balance of each deployed test contract.

sender: Address

The address which will be executing all tests.

ffi: bool

Enables the FFI cheatcode.

always_use_create_2_factory: bool

Use the create 2 factory in all cases including tests and non-broadcasting scripts.

verbosity: u8

Verbosity mode of EVM output as number of occurrences.

memory_limit: u64

The memory limit per EVM execution in bytes. If this limit is exceeded, a MemoryLimitOOG result is thrown.

isolate: bool

Whether to enable isolation of calls.

disable_block_gas_limit: bool

Whether to disable block gas limit checks.

enable_tx_gas_limit: bool

Whether to enable tx gas limit checks as imposed by Osaka (EIP-7825).

networks: NetworkConfigs

Networks with enabled features.

create2_deployer: Address

The CREATE2 deployer’s address.

fork_endpoint: Option<ForkEndpointIdentity>

Identity discovered from the configured fork endpoint.

expected_fork_endpoint: Option<ForkEndpointIdentity>

Endpoint identity that must remain stable while constructing local execution state.

fork_network_is_inferred: bool

Whether the active network selection was inferred from the fork endpoint.

fork_chain_id_is_inferred: bool

Whether env.chain_id was inferred from the fork endpoint.

fork_block_number_is_inferred: bool

Whether fork_block_number was pinned from the fork endpoint’s latest block.

Implementations

impl EvmOpts

fn clear_endpoint_derived_fork_state(&mut self)

Clears state derived from a fork endpoint while preserving explicit configuration.

pub fn set_fork_url(&mut self, fork_url: String)

Selects a new fork URL and clears endpoint-derived state from the previous source.

pub fn invalidate_fork_endpoint_if_source_changed( &mut self, fork: &ResolvedFork, ) -> bool

Invalidates endpoint-derived state when the effective RPC source changed since fork was resolved.

The effective source consists of the URL, active headers, and JWT. Explicit block, network, and chain-ID selections are retained so the new source is resolved under the same user configuration.

pub fn set_explicit_network(&mut self, network: NetworkVariant)

Applies an explicit network override, replacing any endpoint-inferred selection.

pub fn expect_fork_endpoint( &mut self, identity: ForkEndpointIdentity, network_is_inferred: bool, )

Requires subsequent local fork construction to use this exact endpoint identity.

fn ensure_expected_fork_endpoint( &self, identity: &ForkEndpointIdentity, ) -> Result<()>

fn chain_id_override(&self) -> Option<ChainId>

fn endpoint_network_fallback(&self) -> NetworkConfigs

fn anvil_node_info_probe(&self) -> AnvilNodeInfoProbe

fn fork_source_headers(&self) -> Option<&[String]>

fn resolved_fork( &self, fork_url: &str, block: BlockNumHash, context: ForkContext, ) -> ResolvedFork

pub async fn pin_fork_block(&mut self) -> Result<Option<BlockNumber>>

Resolves and pins an unpinned fork to the current latest block.

pub async fn resolve_fork(&self) -> Result<Option<ResolvedFork>>

Resolves the configured fork selector without changing it.

pub async fn can_use_create2_deployer( &self, fork_block: Option<BlockNumber>, ) -> Result<bool>

Returns whether the configured CREATE2 deployer can be used for library linking.

Locally Foundry can only install its canonical deployer. On forks, any deployer with code is usable because the call executes against the forked state.

pub async fn can_use_create2_deployer_resolved( &self, fork: Option<&ResolvedFork>, ) -> Result<bool>

Returns whether the configured CREATE2 deployer existed at the resolved fork block.

pub fn resolved_fork_matches(&self, fork: &ResolvedFork) -> bool

Returns whether fork was resolved from the currently configured source and selector.

pub fn provider_for_resolved_fork<N: Network>( &self, fork: &ResolvedFork, ) -> Result<RootProvider<N>>

Returns a provider configured for an already resolved fork.

async fn ensure_resolved_fork_endpoint<N: Network, P: Provider<N>>( &self, provider: &P, fork: &ResolvedFork, ) -> Result<()>

pub async fn transaction_count_at_resolved_fork( &self, account: Address, fork: &ResolvedFork, ) -> Result<u64>

Returns an account nonce at the exact block and endpoint identity of fork.

pub fn fork_provider_with_url<N: Network>( &self, fork_url: &str, ) -> Result<RootProvider<N>>

Returns a RootProvider for the given fork URL configured with options in self and annotated Network type.

pub async fn infer_network_from_fork(&mut self) -> Result<()>

Infers the network configuration and exact endpoint identity for a fork.

Explicit network selections are preserved, while endpoint identity is still cached so downstream execution can honor an Anvil endpoint’s exact hardfork.

pub async fn discover_fork_endpoint(&self) -> Result<ForkEndpointIdentity>

Discovers the complete identity exposed by the configured fork endpoint.

async fn resolve_fork_endpoint_once<N: Network, P: Provider<N>>( &self, provider: &P, node_info_probe: &mut AnvilNodeInfoProbe, hardfork_policy: EndpointHardforkPolicy, ) -> Result<ForkEndpointIdentity>

Resolves one endpoint identity snapshot, using Anvil’s authoritative node metadata when it is already known to be available.

pub async fn fork_network(&self) -> Result<(ChainId, NetworkVariant)>

Resolves the chain ID and network family exposed by the configured fork endpoint.

Unlike Self::infer_network_from_fork, this always inspects the endpoint. Endpoints whose custom chain ID does not identify a supported network family retain Foundry’s historical Ethereum fallback when anvil_nodeInfo is unavailable.

async fn resolve_fork_endpoint_identity<N: Network, P: Provider<N>>( provider: &P, endpoint: &str, execution_chain_id: ChainId, node_info: Option<NodeInfo>, unknown_fallback: Option<NetworkConfigs>, hardfork_policy: EndpointHardforkPolicy, ) -> Result<ForkEndpointIdentity>

pub async fn env<SPEC: Into<SpecId> + Default + Copy, BLOCK: FoundryBlock + Default, TX: FoundryTransaction + Default>( &self, ) -> Result<(EvmEnv<SPEC, BLOCK>, TX, Option<BlockNumber>)>

Returns a tuple with EvmEnv, TxEnv, and the actual fork block number.

If a fork_url is set, creates a provider and passes it to both EvmOpts::fork_evm_env and EvmOpts::fork_tx_env. Falls back to local settings when no fork URL is configured.

The fork block number is returned separately because on some L2s (e.g., Arbitrum) the block_env.number may be remapped (to the L1 block number) and therefore cannot be used to pin the fork.

pub async fn env_resolved<SPEC: Into<SpecId> + Default + Copy, BLOCK: FoundryBlock + Default, TX: FoundryTransaction + Default>( &self, ) -> Result<(EvmEnv<SPEC, BLOCK>, TX, Option<ResolvedFork>)>

Returns the EVM and transaction environments with their resolved fork context.

pub async fn env_with_fork_context<SPEC: Into<SpecId> + Default + Copy, BLOCK: FoundryBlock + Default, TX: FoundryTransaction + Default>( &self, ) -> Result<(EvmEnv<SPEC, BLOCK>, TX, Option<ForkContext>)>

Returns the execution environment and the source identity of its remote fork, if any.

The source chain ID is always fetched from the fork endpoint, even when the execution environment applies a configured CHAINID opcode override.

pub async fn env_with_resolved_fork<SPEC: Into<SpecId> + Default + Copy, BLOCK: FoundryBlock + Default, TX: FoundryTransaction + Default>( &self, fork: Option<&ResolvedFork>, ) -> Result<(EvmEnv<SPEC, BLOCK>, TX)>

Returns the EVM and transaction environments at an already resolved fork.

pub async fn fork_evm_env<SPEC: Into<SpecId> + Default + Copy, BLOCK: FoundryBlock + Default, N: Network, P: Provider<N>>( &self, provider: &P, ) -> Result<(EvmEnv<SPEC, BLOCK>, BlockNumber)>

Returns the EvmEnv (cfg + block) and [BlockNumber] fetched from the fork endpoint via provider

pub(crate) async fn fork_evm_env_resolved<SPEC: Into<SpecId> + Default + Copy, BLOCK: FoundryBlock + Default, N: Network, P: Provider<N>>( &self, provider: &P, ) -> Result<(EvmEnv<SPEC, BLOCK>, ResolvedFork)>

Returns the EVM environment and block identity fetched from the fork endpoint.

async fn fork_evm_env_resolved_with_context<SPEC: Into<SpecId> + Default + Copy, BLOCK: FoundryBlock + Default, N: Network, P: Provider<N>>( &self, provider: &P, node_info_probe: &mut AnvilNodeInfoProbe, ) -> Result<(EvmEnv<SPEC, BLOCK>, BlockNumHash, ForkContext)>

Returns the fork environment, exact block, and endpoint identity resolved together.

fn fork_env_error_context(&self) -> String

async fn resolve_fork_block_with_context<N: Network, P: Provider<N>>( &self, provider: &P, target: ForkBlockTarget, node_info_probe: &mut AnvilNodeInfoProbe, ) -> Result<(N::BlockResponse, BlockNumHash, ForkContext)>

async fn fork_evm_env_at_resolved_with_context<SPEC: Into<SpecId> + Default + Copy, BLOCK: FoundryBlock + Default, N: Network, P: Provider<N>>( &self, provider: &P, expected: &ResolvedFork, node_info_probe: &mut AnvilNodeInfoProbe, ) -> Result<(EvmEnv<SPEC, BLOCK>, ForkContext)>

pub(crate) async fn fork_evm_env_at_resolved<SPEC: Into<SpecId> + Default + Copy, BLOCK: FoundryBlock + Default, N: Network, P: Provider<N>>( &self, provider: &P, expected: &ResolvedFork, ) -> Result<EvmEnv<SPEC, BLOCK>>

Reconstructs the fork environment at an already resolved exact block.

fn fork_env_from_block<SPEC: Into<SpecId> + Default + Copy, BLOCK: FoundryBlock + Default, N: Network>( &self, chain_id: ChainId, source_chain_id: ChainId, block: &N::BlockResponse, ) -> EvmEnv<SPEC, BLOCK>

fn local_evm_env<SPEC: Into<SpecId> + Default + Clone, BLOCK: FoundryBlock + Default>( &self, ) -> EvmEnv<SPEC, BLOCK>

Returns the EvmEnv configured with only local settings.

fn fork_tx_env<TX: FoundryTransaction + Default>( &self, gas_price: u128, chain_id: ChainId, ) -> TX

Returns the TxEnv with gas price and chain ID from a stable fork snapshot.

fn local_tx_env<TX: FoundryTransaction + Default>(&self) -> TX

Returns the TxEnv configured from local settings only.

fn cfg_env<SPEC: Into<SpecId> + Default + Clone>( &self, chain_id: ChainId, ) -> CfgEnv<SPEC>

Builds a [CfgEnv] from the options, using the provided [ChainId].

pub fn get_fork( &self, config: &Config, chain_id: u64, fork_block_number: Option<BlockNumber>, ) -> Option<CreateFork>

Helper function that returns the CreateFork to use, if any.

storage caching for the CreateFork will be enabled if

• fork_url is present
• fork_block_number is present
• StorageCachingConfig allows the fork_url + source chain ID pair
• storage is allowed (no_storage_caching = false)

If all these criteria are met, then storage caching is enabled and storage info will be written to <Config::foundry_cache_dir()>/<str(chainid)>/<block>/storage.json.

for mainnet and --fork-block-number 14435000 on mac the corresponding storage cache will be at ~/.foundry/cache/mainnet/14435000/storage.json. fork_block_number is the actual block number to pin the fork to. This must be the real chain block number, not a remapped value. On some L2s (e.g., Arbitrum) block_env.number is remapped to the L1 block number, so callers must pass the original block number returned by EvmOpts::env instead.

pub fn get_fork_resolved( &self, config: &Config, chain_id: u64, fork: Option<&ResolvedFork>, ) -> Option<CreateFork>

Returns a fork configuration pinned to an already resolved block identity.

fn get_fork_with_identity( &self, config: &Config, chain_id: u64, fork_block_number: Option<BlockNumber>, resolved: Option<ResolvedFork>, ) -> Option<CreateFork>

pub fn gas_limit(&self) -> u64

Returns the gas limit to use

const fn get_compute_units_per_second(&self) -> u64

Returns the available compute units per second, which will be

• u64::MAX, if no_rpc_rate_limit if set (as rate limiting is disabled)
• the assigned compute units, if compute_units_per_second is set
• ALCHEMY_FREE_TIER_CUPS (330) otherwise

pub async fn get_remote_chain_id(&self) -> Option<Chain>

Returns the chain ID from the RPC, if any.

Trait Implementations

impl Clone for EvmOpts

fn clone(&self) -> EvmOpts

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EvmOpts

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

Formats the value using the given formatter.

impl Default for EvmOpts

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EvmOpts

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EvmOpts

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

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