Struct CowBackend

pub struct CowBackend<'a> {
    pub backend: Cow<'a, Backend>,
    is_initialized: bool,
    spec_id: SpecId,
}

A wrapper around Backend that ensures only revm::DatabaseRef functions are called.

Any changes made during its existence that affect the caching layer of the underlying Database will result in a clone of the initial Database. Therefore, this backend type is basically a clone-on-write Backend, where cloning is only necessary if cheatcodes will modify the Backend

Entire purpose of this type is for fuzzing. A test function fuzzer will repeatedly execute the function via immutable raw (no state changes) calls.

N.B.: we’re assuming cheatcodes that alter the state (like multi fork swapping) are niche. If they executed, it will require a clone of the initial input database. This way we can support these cheatcodes cheaply without adding overhead for tests that don’t make use of them. Alternatively each test case would require its own Backend clone, which would add significant overhead for large fuzz sets even if the Database is not big after setup.

Fields

backend: Cow<'a, Backend>

The underlying Backend.

No calls on the CowBackend will ever persistently modify the backend’s state.

is_initialized: bool

spec_id: SpecId

Implementations

impl<'a> CowBackend<'a>

pub fn new_borrowed(backend: &'a Backend) -> CowBackend<'a>

Creates a new CowBackend with the given Backend.

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

where I: InspectorExt,

Executes the configured transaction of the env without committing state changes

Note: in case there are any cheatcodes executed that modify the environment, this will update the given env with the new values.

pub fn has_state_snapshot_failure(&self) -> bool

Returns whether there was a state snapshot failure in the backend.

This is bubbled up from the underlying Copy-On-Write backend when a revert occurs.

Trait Implementations

impl<'a> Clone for CowBackend<'a>

fn clone(&self) -> CowBackend<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Database for CowBackend<'_>

type Error = DatabaseError

The database error type.

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

Get basic account information.

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

Get account code by its hash.

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

Get storage value of address at index.

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

Get block hash by block number.

impl DatabaseCommit for CowBackend<'_>

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

Commit changes to the database.

impl DatabaseExt for CowBackend<'_>

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

Creates a new state snapshot at the current point of execution.

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

Reverts the snapshot if it exists

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

Deletes the state snapshot with the given id

fn delete_state_snapshots(&mut self)

Deletes all state snapshots.

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

Creates a new fork but does not select it

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

Creates a new fork but does not select it

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

Selects the fork’s state

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

Updates the fork to given block number.

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

Updates the fork to given transaction hash

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

Fetches the given transaction for the fork and executes it, committing the state in the DB

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

Executes a given TransactionRequest, commits the new state to the DB

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

Returns the ForkId that’s currently used in the database, if fork mode is on

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

Returns the Fork url that’s currently used in the database, if fork mode is on

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

Ensures that an appropriate fork exists

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

Ensures that a corresponding ForkId exists for the given local id

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

Handling multiple accounts/new contracts in a multifork environment can be challenging since every fork has its own standalone storage section. So this can be a common error to run into:

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

Loads the account allocs from the given allocs map into the passed [JournaledState].

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

Copies bytecode, storage, nonce and balance from the given genesis account to the target address.

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

Returns true if the given account is currently marked as persistent.

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

Revokes persistent status from the given account.

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

Marks the given account as persistent.

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

Grants cheatcode access for the given account

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

Revokes cheatcode access for the given account

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

Returns true if the given account is allowed to execute cheatcodes

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

Set the blockhash for a given block number.

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

Creates and also selects a new fork

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>

Creates and also selects a new fork

fn is_forked_mode(&self) -> bool

Whether the database is currently in forked mode.

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

where Self: Sized,

Removes persistent status from all given accounts.

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

where Self: Sized,

Extends the persistent accounts with the accounts the iterator yields.

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

Ensures that account is allowed to execute cheatcodes

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

Same as Self::ensure_cheatcode_access() but only enforces it if the backend is currently in forking mode

impl DatabaseRef for CowBackend<'_>

type Error = DatabaseError

The database error type.

fn basic_ref( &self, address: Address, ) -> Result<Option<AccountInfo>, <CowBackend<'_> as DatabaseRef>::Error>

Get basic account information.

fn code_by_hash_ref( &self, code_hash: FixedBytes<32>, ) -> Result<Bytecode, <CowBackend<'_> as DatabaseRef>::Error>

Get account code by its hash.

fn storage_ref( &self, address: Address, index: Uint<256, 4>, ) -> Result<Uint<256, 4>, <CowBackend<'_> as DatabaseRef>::Error>

Get storage value of address at index.

fn block_hash_ref( &self, number: u64, ) -> Result<FixedBytes<32>, <CowBackend<'_> as DatabaseRef>::Error>

Get block hash by block number.

impl<'a> Debug for CowBackend<'a>

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

Formats the value using the given formatter.

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