Struct Backend

Source

pub struct Backend {
    forks: MultiFork,
    mem_db: CacheDB<EmptyDBWrapper>,
    fork_init_journaled_state: JournaledState,
    active_fork_ids: Option<(Uint<256, 4>, usize)>,
    inner: BackendInner,
}

Expand description

Provides the underlying revm::Database implementation.

A Backend can be initialised in two forms:

§1. Empty in-memory Database

This is the default variant: an empty revm::Database

§2. Forked Database

A revm::Database that forks off a remote client

In addition to that we support forking manually on the fly. Additional forks can be created. Each unique fork is identified by its unique ForkId. We treat forks as unique if they have the same (endpoint, block number) pair.

When it comes to testing, it’s intended that each contract will use its own Backend (Backend::clone). This way each contract uses its own encapsulated evm state. For in-memory testing, the database is just an owned revm::InMemoryDB.

Each Fork, identified by a unique id, uses completely separate storage, write operations are performed only in the fork’s own database, ForkDB.

A ForkDB consists of 2 halves:

everything fetched from the remote is readonly
all local changes (instructed by the contract) are written to the backend’s db and don’t alter the state of the remote client.

§Fork swapping

Multiple “forks” can be created Backend::create_fork(), however only 1 can be used by the db. However, their state can be hot-swapped by swapping the read half of db from one fork to another. When swapping forks (Backend::select_fork()) we also update the current Env of the EVM accordingly, so that all block.* config values match

When another for is selected DatabaseExt::select_fork() the entire storage, including JournaledState is swapped, but the storage of the caller’s and the test contract account is always cloned. This way a fork has entirely separate storage but data can still be shared across fork boundaries via stack and contract variables.

§Snapshotting

A snapshot of the current overall state can be taken at any point in time. A snapshot is identified by a unique id that’s returned when a snapshot is created. A snapshot can only be reverted once. After a successful revert, the same snapshot id cannot be used again. Reverting a snapshot replaces the current active state with the snapshot state, the snapshot is deleted afterwards, as well as any snapshots taken after the reverted snapshot, (e.g.: reverting to id 0x1 will delete snapshots with ids 0x1, 0x2, etc.)

Note: State snapshots work across fork-swaps, e.g. if fork A is currently active, then a snapshot is created before fork B is selected, then fork A will be the active fork again after reverting the snapshot.

Fields§

§forks: MultiFork§mem_db: CacheDB<EmptyDBWrapper>§fork_init_journaled_state: JournaledState§active_fork_ids: Option<(Uint<256, 4>, usize)>§inner: BackendInner

Struct BackendCopy item path

§1. Empty in-memory Database

§2. Forked Database

§Fork swapping

§Snapshotting

Fields§

Implementations§

impl Backend

pub fn spawn(fork: Option<CreateFork>) -> Backend

pub fn new(forks: MultiFork, fork: Option<CreateFork>) -> Backend

pub fn clone_empty(&self) -> Backend

pub fn insert_account_info(&mut self, address: Address, account: AccountInfo)

pub fn insert_account_storage( &mut self, address: Address, slot: Uint<256, 4>, value: Uint<256, 4>, ) -> Result<(), DatabaseError>

pub fn replace_account_storage( &mut self, address: Address, storage: HashMap<Uint<256, 4>, Uint<256, 4>, RandomState>, ) -> Result<(), DatabaseError>

pub fn state_snapshots( &self, ) -> &StateSnapshots<BackendStateSnapshot<BackendDatabaseSnapshot>>

pub fn set_test_contract(&mut self, acc: Address) -> &mut Backend

pub fn set_caller(&mut self, acc: Address) -> &mut Backend

pub fn set_spec_id(&mut self, spec_id: SpecId) -> &mut Backend

pub fn caller_address(&self) -> Option<Address>

pub fn has_state_snapshot_failure(&self) -> bool

pub fn set_state_snapshot_failure(&mut self, has_state_snapshot_failure: bool)

pub fn mem_db(&self) -> &CacheDB<EmptyDBWrapper>

pub fn is_active_fork(&self, id: Uint<256, 4>) -> bool

pub fn is_in_forking_mode(&self) -> bool

pub fn active_fork(&self) -> Option<&Fork>

pub fn active_fork_mut(&mut self) -> Option<&mut Fork>

pub fn active_fork_db(&self) -> Option<&CacheDB<SharedBackend>>

pub fn active_fork_db_mut(&mut self) -> Option<&mut CacheDB<SharedBackend>>

pub fn db(&self) -> &dyn Database<Error = DatabaseError>

pub fn db_mut(&mut self) -> &mut dyn Database<Error = DatabaseError>

pub fn merged_logs(&self, logs: Vec<Log>) -> Vec<Log>

pub fn inspect<I>( &mut self, env: &mut EnvWithHandlerCfg, inspector: &mut I, ) -> Result<ResultAndState, Report>where I: InspectorExt,

pub fn is_existing_precompile(&self, addr: &Address) -> bool

pub fn replay_until( &mut self, id: Uint<256, 4>, env: Env, tx_hash: FixedBytes<32>, journaled_state: &mut JournaledState, ) -> Result<Option<Transaction<AnyTxEnvelope>>, Report>

Trait Implementations§

impl Clone for Backend

fn clone(&self) -> Backend

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

impl Database for Backend

type Error = DatabaseError

fn basic( &mut self, address: Address, ) -> Result<Option<AccountInfo>, <Backend as Database>::Error>

fn code_by_hash( &mut self, code_hash: FixedBytes<32>, ) -> Result<Bytecode, <Backend as Database>::Error>

fn storage( &mut self, address: Address, index: Uint<256, 4>, ) -> Result<Uint<256, 4>, <Backend as Database>::Error>

fn block_hash( &mut self, number: u64, ) -> Result<FixedBytes<32>, <Backend as Database>::Error>

impl DatabaseCommit for Backend

fn commit(&mut self, changes: HashMap<Address, Account, RandomState>)

impl DatabaseExt for Backend

fn select_fork( &mut self, id: Uint<256, 4>, env: &mut Env, active_journaled_state: &mut JournaledState, ) -> Result<(), Report>

fn roll_fork( &mut self, id: Option<Uint<256, 4>>, block_number: u64, env: &mut Env, journaled_state: &mut JournaledState, ) -> Result<(), Report>

fn load_allocs( &mut self, allocs: &BTreeMap<Address, GenesisAccount>, journaled_state: &mut JournaledState, ) -> Result<(), BackendError>

fn clone_account( &mut self, source: &GenesisAccount, target: &Address, journaled_state: &mut JournaledState, ) -> Result<(), BackendError>

fn snapshot_state( &mut self, journaled_state: &JournaledState, env: &Env, ) -> Uint<256, 4>

fn revert_state( &mut self, id: Uint<256, 4>, current_state: &JournaledState, current: &mut Env, action: RevertStateSnapshotAction, ) -> Option<JournaledState>

fn delete_state_snapshot(&mut self, id: Uint<256, 4>) -> bool

fn delete_state_snapshots(&mut self)

fn create_fork( &mut self, create_fork: CreateFork, ) -> Result<Uint<256, 4>, Report>

fn create_fork_at_transaction( &mut self, fork: CreateFork, transaction: FixedBytes<32>, ) -> Result<Uint<256, 4>, Report>

fn roll_fork_to_transaction( &mut self, id: Option<Uint<256, 4>>, transaction: FixedBytes<32>, env: &mut Env, journaled_state: &mut JournaledState, ) -> Result<(), Report>

fn transact( &mut self, maybe_id: Option<Uint<256, 4>>, transaction: FixedBytes<32>, env: Env, journaled_state: &mut JournaledState, inspector: &mut dyn InspectorExt, ) -> Result<(), Report>

fn transact_from_tx( &mut self, tx: &TransactionRequest, env: Env, journaled_state: &mut JournaledState, inspector: &mut dyn InspectorExt, ) -> Result<(), Report>

fn active_fork_id(&self) -> Option<Uint<256, 4>>

fn active_fork_url(&self) -> Option<String>

fn ensure_fork(&self, id: Option<Uint<256, 4>>) -> Result<Uint<256, 4>, Report>

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

fn diagnose_revert( &self, callee: Address, journaled_state: &JournaledState, ) -> Option<RevertDiagnostic>

fn add_persistent_account(&mut self, account: Address) -> bool

fn remove_persistent_account(&mut self, account: &Address) -> bool

fn is_persistent(&self, acc: &Address) -> bool

fn allow_cheatcode_access(&mut self, account: Address) -> bool

fn revoke_cheatcode_access(&mut self, account: &Address) -> bool

fn has_cheatcode_access(&self, account: &Address) -> bool

fn set_blockhash( &mut self, block_number: Uint<256, 4>, block_hash: FixedBytes<32>, )

fn create_select_fork( &mut self, fork: CreateFork, env: &mut Env, journaled_state: &mut JournaledState, ) -> Result<Uint<256, 4>, Report>

fn create_select_fork_at_transaction( &mut self, fork: CreateFork, env: &mut Env, journaled_state: &mut JournaledState, transaction: FixedBytes<32>, ) -> Result<Uint<256, 4>, Report>

fn is_forked_mode(&self) -> bool

fn remove_persistent_accounts( &mut self, accounts: impl IntoIterator<Item = Address>, )where Self: Sized,

fn extend_persistent_accounts( &mut self, accounts: impl IntoIterator<Item = Address>, )where Self: Sized,

fn ensure_cheatcode_access(&self, account: &Address) -> Result<(), BackendError>

fn ensure_cheatcode_access_forking_mode( &self, account: &Address, ) -> Result<(), BackendError>

impl DatabaseRef for Backend

Struct Backend

pub fn inspect<I>( &mut self, env: &mut EnvWithHandlerCfg, inspector: &mut I, ) -> Result<ResultAndState, Report>
where I: InspectorExt,

fn remove_persistent_accounts( &mut self, accounts: impl IntoIterator<Item = Address>, )
where Self: Sized,

fn extend_persistent_accounts( &mut self, accounts: impl IntoIterator<Item = Address>, )
where Self: Sized,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

fn conv<T>(self) -> T
where Self: Into<T>,

impl<T> DynClone for T
where T: Clone,

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

impl<T> FromRef<T> for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

impl<T> Paint for T
where T: ?Sized,