Struct BackendInner

pub struct BackendInner {
    pub launched_with_fork: Option<(ForkId, Uint<256, 4>, usize)>,
    pub issued_local_fork_ids: HashMap<Uint<256, 4>, ForkId>,
    pub created_forks: HashMap<ForkId, usize>,
    pub forks: Vec<Option<Fork>>,
    pub state_snapshots: StateSnapshots<BackendStateSnapshot<BackendDatabaseSnapshot>>,
    pub has_state_snapshot_failure: bool,
    pub caller: Option<Address>,
    pub next_fork_id: Uint<256, 4>,
    pub persistent_accounts: HashSet<Address>,
    pub spec_id: SpecId,
    pub cheatcode_access_accounts: HashSet<Address>,
}

Container type for various Backend related data

Fields

launched_with_fork: Option<(ForkId, Uint<256, 4>, usize)>

Stores the ForkId of the fork the Backend launched with from the start.

In other words if Backend::spawn() was called with a CreateFork command, to launch directly in fork mode, this holds the corresponding fork identifier of this fork.

issued_local_fork_ids: HashMap<Uint<256, 4>, ForkId>

This tracks numeric fork ids and the ForkId used by the handler.

This is necessary, because there can be multiple Backends associated with a single ForkId which is only a pair of endpoint + block. Since an existing fork can be modified (e.g. roll_fork), but this should only affect the fork that’s unique for the test and not the ForkId

This ensures we can treat forks as unique from the context of a test, so rolling to another is basically creating(or reusing) another ForkId that’s then mapped to the previous issued local numeric identifier, that remains constant, even if the underlying fork backend changes.

created_forks: HashMap<ForkId, usize>

tracks all the created forks Contains the index of the corresponding ForkDB in the forks vec

forks: Vec<Option<Fork>>

Holds all created fork databases

state_snapshots: StateSnapshots<BackendStateSnapshot<BackendDatabaseSnapshot>>

Contains state snapshots made at a certain point

has_state_snapshot_failure: bool

Tracks whether there was a failure in a snapshot that was reverted

The Test contract contains a bool variable that is set to true when an assert function failed. When a snapshot is reverted, it reverts the state of the evm, but we still want to know if there was an assert that failed after the snapshot was taken so that we can check if the test function passed all asserts even across snapshots. When a snapshot is reverted we get the current revm::JournaledState which contains the state that we can check if the _failed variable is set, additionally

caller: Option<Address>

Tracks the caller of the test function

next_fork_id: Uint<256, 4>

Tracks numeric identifiers for forks

persistent_accounts: HashSet<Address>

All accounts that should be kept persistent when switching forks. This means all accounts stored here don’t use a separate storage section on each fork instead the use only one that’s persistent across fork swaps.

spec_id: SpecId

The configured spec id

cheatcode_access_accounts: HashSet<Address>

All accounts that are allowed to execute cheatcodes

Implementations

impl BackendInner

pub fn ensure_fork_id(&self, id: Uint<256, 4>) -> Result<&ForkId, Report>

pub fn ensure_fork_index(&self, id: &ForkId) -> Result<usize, Report>

pub fn ensure_fork_index_by_local_id( &self, id: Uint<256, 4>, ) -> Result<usize, Report>

pub fn forks_iter(&self) -> impl Iterator<Item = (Uint<256, 4>, &Fork)>

Returns an iterator over Forks

pub fn forks_iter_mut(&mut self) -> impl Iterator<Item = &mut Fork>

Returns a mutable iterator over all Forks

pub fn revert_state_snapshot( &mut self, id: Uint<256, 4>, fork_id: ForkId, idx: usize, fork: Fork, )

Reverts the entire fork database

pub fn update_fork_mapping( &mut self, id: Uint<256, 4>, fork_id: ForkId, db: CacheDB<SharedBackend>, journaled_state: JournaledState, ) -> usize

Updates the fork and the local mapping and returns the new index for the fork_db

pub fn roll_fork( &mut self, id: Uint<256, 4>, new_fork_id: ForkId, backend: SharedBackend, ) -> Result<usize, Report>

pub fn insert_new_fork( &mut self, fork_id: ForkId, db: CacheDB<SharedBackend>, journaled_state: JournaledState, ) -> (Uint<256, 4>, usize)

Inserts a new ForkDB and issues a new local fork identifier

Also returns the index where the ForDB is stored

pub fn len(&self) -> usize

Returns the number of issued ids

pub fn is_empty(&self) -> bool

Returns true if no forks are issued

pub fn precompiles(&self) -> &'static Precompiles

pub fn new_journaled_state(&self) -> JournaledState

Returns a new, empty, JournaledState with set precompiles

Trait Implementations

impl Clone for BackendInner

fn clone(&self) -> BackendInner

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BackendInner

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

Formats the value using the given formatter.

impl Default for BackendInner

fn default() -> BackendInner

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