Struct Anvil 

pub struct Anvil { /* private fields */ }

Builder for launching anvil.

Anvil::spawn panics on any startup failure; use Anvil::try_spawn to handle errors.

Example

use alloy_node_bindings::Anvil;

let anvil = Anvil::new()
    .mnemonic("abstract vacuum mammal awkward pudding scene penalty purchase dinner depart evoke puzzle")
    .try_spawn()?;
println!("Anvil is listening at {}", anvil.endpoint());

drop(anvil); // this will kill the instance

Implementations

impl Anvil

pub fn new() -> Self

Creates an Anvil builder.

Unless configured, port zero is passed so the OS chooses an available port, while account and mnemonic defaults are left to Anvil.

Example

fn a() {
 let anvil = Anvil::default().spawn();

 println!("Anvil running at `{}`", anvil.endpoint());

pub fn at(path: impl Into<PathBuf>) -> Self

Creates an Anvil builder which will execute anvil at the given path.

Example

Paths are passed directly to Command, so shell expansions such as ~ are not performed.

let anvil = Anvil::at("/path/to/anvil").try_spawn()?;

println!("Anvil running at `{}`", anvil.endpoint());

pub fn path<T: Into<PathBuf>>(self, path: T) -> Self

Sets the path to the anvil cli

By default, it’s expected that anvil is in $PATH, see also std::process::Command::new()

pub fn host<T: Into<String>>(self, host: T) -> Self

Sets the host which will be used when the anvil instance is launched.

pub fn port<T: Into<u16>>(self, port: T) -> Self

Sets the port which will be used when the anvil instance is launched.

Port zero asks the OS to choose an available port. Read AnvilInstance::port or AnvilInstance::endpoint after spawning to obtain the selected value.

pub fn ipc_path(self, path: impl Into<String>) -> Self

Sets the path for the ipc server

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

Sets the chain_id the anvil instance will use.

If not set, the instance defaults to chain id 31337.

pub fn mnemonic<T: Into<String>>(self, mnemonic: T) -> Self

Sets the mnemonic which will be used when the anvil instance is launched.

pub const fn block_time(self, block_time: u64) -> Self

Sets the block-time in seconds which will be used when the anvil instance is launched.

pub const fn block_time_f64(self, block_time: f64) -> Self

Sets the block-time in sub-seconds which will be used when the anvil instance is launched. Older versions of anvil do not support sub-second block times.

pub const fn fork_block_number(self, fork_block_number: u64) -> Self

Sets the fork-block-number which will be used in addition to Self::fork.

Note: if set, then this requires fork to be set as well

pub fn fork<T: Into<String>>(self, fork: T) -> Self

Sets the fork argument to fork from another currently running Ethereum client at a given block. Input should be the HTTP location and port of the other client, e.g. http://localhost:8545. You can optionally specify the block to fork from using an @ sign: http://localhost:8545@1599200

pub fn hardfork(self, hardfork: EthereumHardfork) -> Self

Select the EthereumHardfork to start anvil with.

pub fn paris(self) -> Self

Set the EthereumHardfork to EthereumHardfork::Paris.

pub fn cancun(self) -> Self

Set the EthereumHardfork to EthereumHardfork::Cancun.

pub fn shanghai(self) -> Self

Set the EthereumHardfork to EthereumHardfork::Shanghai.

pub fn prague(self) -> Self

Set the EthereumHardfork to EthereumHardfork::Prague.

pub fn odyssey(self) -> Self

Instantiate anvil with the --odyssey flag.

pub fn auto_impersonate(self) -> Self

Instantiate anvil with the --auto-impersonate flag.

pub fn push_arg<T: Into<OsString>>(&mut self, arg: T)

Adds an argument to pass to the anvil.

pub fn extend_args<I, S>(&mut self, args: I)

where I: IntoIterator<Item = S>, S: Into<OsString>,

Adds multiple arguments to pass to the anvil.

pub fn arg<T: Into<OsString>>(self, arg: T) -> Self

Adds an argument to pass to the anvil.

pub fn args<I, S>(self, args: I) -> Self

where I: IntoIterator<Item = S>, S: Into<OsString>,

Adds multiple arguments to pass to the anvil.

pub fn env<K, V>(self, key: K, value: V) -> Self

where K: Into<OsString>, V: Into<OsString>,

Adds an environment variable to pass to the anvil.

pub fn envs<I, K, V>(self, envs: I) -> Self

where I: IntoIterator<Item = (K, V)>, K: Into<OsString>, V: Into<OsString>,

Adds multiple environment variables to pass to the anvil.

pub const fn timeout(self, timeout: u64) -> Self

Sets the timeout which will be used when the anvil instance is launched. Units: milliseconds.

pub const fn keep_stdout(self) -> Self

Keep the handle to anvil’s stdout in order to read from it.

Caution: if the stdout handle isn’t used, this can end up blocking.

pub fn spawn(self) -> AnvilInstance

Consumes the builder and spawns anvil.

Panics

If spawning the instance fails at any point.

pub fn try_spawn(self) -> Result<AnvilInstance, NodeError>

Consumes the builder, spawns anvil, and waits for it to report its listening address.

Returns an error if the process cannot be started or does not become ready before the configured Self::timeout is observed. The deadline is checked between complete stdout lines; a live process that emits no newline can block this call past the deadline.

Trait Implementations

impl Clone for Anvil

fn clone(&self) -> Anvil

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Anvil

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

Formats the value using the given formatter.

impl Default for Anvil

fn default() -> Anvil

Returns the “default value” for a type.

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