Struct NetworkConfigs 

pub struct NetworkConfigs {
    pub(crate) network: Option<NetworkVariant>,
    pub(crate) celo: bool,
    pub(crate) optimism: bool,
    pub(crate) tempo: bool,
    pub(crate) monad: bool,
    pub(crate) bypass_prevrandao: bool,
}

Fields

network: Option<NetworkVariant>

Enable a specific network family.

celo: bool

Enable Celo network features.

optimism: bool

Enable Optimism network features (deprecated: use –network optimism).

tempo: bool

Enable Tempo network features (deprecated: use –network tempo).

monad: bool

Enable Monad network features (deprecated: use –network monad).

bypass_prevrandao: bool

Whether to bypass prevrandao.

Implementations

impl NetworkConfigs

pub fn with_optimism() -> Self

pub const fn is_optimism(&self) -> bool

pub(crate) fn op_base_fee_params(&self, timestamp: u64) -> BaseFeeParams

Optimism-specific base fee parameters, picking Canyon vs pre-Canyon based on timestamp.

impl NetworkConfigs

pub fn validate(&self) -> Result<(), String>

Validates that all configured network selectors resolve to the same execution profile.

Canonical and legacy selectors for the same family remain compatible. Selectors for different families are rejected instead of being silently resolved by field priority.

pub fn with_ethereum() -> Self

pub fn with_celo() -> Self

pub fn with_tempo() -> Self

pub fn with_monad() -> Self

pub const fn is_tempo(&self) -> bool

pub const fn is_monad(&self) -> bool

pub const fn extra_cheatcode_addresses(&self) -> &'static [Address]

Returns additional cheatcode contract addresses for the active network.

pub const fn is_celo(&self) -> bool

pub const fn resolved_network(&self) -> Option<NetworkVariant>

Returns the resolved network variant, folding legacy flags.

pub const fn has_network_selection(&self) -> bool

Returns whether a network family was selected in this configuration.

pub const fn execution_family_name(&self) -> &'static str

Returns the execution family represented by this configuration.

pub const fn execution_profile_name(&self) -> &'static str

Returns a label for the complete execution configuration.

pub const fn execution_network(&self) -> NetworkVariant

Returns the concrete execution network, treating an unresolved configuration as Ethereum.

pub fn has_same_execution_profile(&self, other: &Self) -> bool

Returns whether both configurations can use the same instantiated EVM backend.

pub const fn supports_fork_source(&self, source: &Self) -> bool

Returns whether this execution configuration can use source as a fork state source without rebuilding the instantiated EVM.

Monad uses a distinct EVM factory and instruction provider, so forks cannot cross the Monad boundary. Existing non-Monad fork-source compatibility remains unchanged.

pub fn active_network_name(&self) -> Option<&'static str>

Returns the name of the currently active non-Ethereum network, or None for plain Ethereum.

pub fn base_fee_params(&self, timestamp: u64) -> BaseFeeParams

Returns the base fee parameters for the configured network.

For Optimism networks, returns Canyon parameters if the Canyon hardfork is active at the given timestamp, otherwise returns pre-Canyon parameters.

pub fn contract_size_limits(&self) -> Option<NetworkContractSizeLimits>

Returns contract size limits for networks that override Ethereum defaults.

pub fn bypass_prevrandao(&self, chain_id: u64) -> bool

pub fn try_with_chain_id(self, chain_id: u64) -> Result<Self, String>

Infers an execution profile from chain_id unless one was selected explicitly.

Unknown chain IDs preserve the unresolved configuration so endpoint metadata can still identify their execution profile. A known chain whose feature is unavailable is rejected instead of silently falling back to Ethereum semantics.

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

Best-effort execution-profile inference for trusted, programmatic chain IDs.

User-provided chain IDs must be handled with Self::try_with_chain_id so an unavailable feature cannot silently select Ethereum semantics.

pub fn with_rpc_network(self, network: NetworkVariant) -> Self

Applies an RPC endpoint’s resolved EVM family to this configuration.

Successful endpoint metadata is authoritative, including when a local Anvil uses a well-known chain ID as an execution override. Orthogonal settings are preserved.

pub fn with_rpc_identity( self, network: NetworkVariant, chain_id: ChainId, ) -> Self

Applies an RPC endpoint’s execution family and chain-specific Ethereum configuration.

The reported family is authoritative. A known Celo chain ID additionally enables Celo’s precompiles because Celo shares the Ethereum EVM factory rather than having its own NetworkVariant.

pub fn canonical_execution_profile(self) -> Self

Returns the canonical endpoint-visible execution profile.

pub fn with_execution_profile(self, profile: Self) -> Self

Applies an authoritative execution profile while preserving orthogonal settings.

pub fn with_rpc_profile(self, profile: Self) -> Self

Applies an endpoint-reported execution profile while preserving orthogonal settings.

pub fn from_node_info_profile(profile: &str) -> Result<Self, String>

Parses the execution profile reported by anvil_nodeInfo.

pub fn from_rpc_identity_profile_with_fallback( chain_id: ChainId, node_info_profile: Option<Option<&str>>, unknown_fallback: Option<Self>, ) -> Result<Option<Self>, String>

Resolves an RPC endpoint’s complete execution profile.

Explicit metadata is authoritative. When metadata is absent or omits the profile, a caller-supplied explicit profile takes precedence over chain-ID inference. Otherwise, legacy Anvil responses and ordinary RPC endpoints recover Celo from a canonical Celo chain ID and preserve the historical behavior for custom chain IDs.

pub fn normalize_for_hardfork( self, hardfork: FoundryHardfork, ) -> Result<Self, String>

Validates hardfork against the current NetworkConfigs and, if consistent, returns an updated instance with the network implied by the enabled hardfork.

Returns Err when the hardfork’s network family conflicts with the configured one.

pub fn inject_precompiles(self, precompiles: &mut PrecompilesMap)

Inject precompiles for configured networks.

pub fn inject_chain_precompiles( self, precompiles: &mut PrecompilesMap, chain_id: ChainId, timestamp: u64, )

Injects chain-specific precompiles active at the given timestamp.

pub fn precompiles_label( self, tempo_hardfork: Option<TempoHardfork>, monad_hardfork: Option<MonadHardfork>, ) -> AddressHashMap<String>

Returns precompiles label for configured networks, to be used in traces.

pub fn precompiles( self, tempo_hardfork: Option<TempoHardfork>, monad_hardfork: Option<MonadHardfork>, ) -> BTreeMap<String, Address>

Returns precompiles for configured networks.

Trait Implementations

impl Args for NetworkConfigs

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

impl Clone for NetworkConfigs

fn clone(&self) -> NetworkConfigs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CommandFactory for NetworkConfigs

fn command<'b>() -> Command

Build a [Command] that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a [Command] that can update self.

impl Copy for NetworkConfigs

impl Debug for NetworkConfigs

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

Formats the value using the given formatter.

impl Default for NetworkConfigs

fn default() -> NetworkConfigs

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NetworkConfigs

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for NetworkConfigs

impl From<NetworkVariant> for NetworkConfigs

fn from(network: NetworkVariant) -> Self

Converts to this type from the input type.

impl FromArgMatches for NetworkConfigs

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Hash for NetworkConfigs

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Parser for NetworkConfigs

fn parse() -> Self

Parse from std::env::args_os(), [exit][Error::exit] on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, [exit][Error::exit] on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, [exit][Error::exit] on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.

impl PartialEq for NetworkConfigs

fn eq(&self, other: &NetworkConfigs) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for NetworkConfigs

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for NetworkConfigs

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