anvil::eth::backend::mem::fork_db

Struct ForkedDatabase

pub struct ForkedDatabase {
    backend: SharedBackend,
    cache_db: CacheDB<SharedBackend>,
    db: BlockchainDb,
    state_snapshots: Arc<Mutex<RawMutex, StateSnapshots<ForkDbStateSnapshot>>>,
}

Expand description

a [revm::Database] that’s forked off another client

The backend is used to retrieve (missing) data, which is then fetched from the remote endpoint. The inner in-memory database holds this storage and will be used for write operations. This database uses the backend for read and the db for write operations. But note the backend will also write (missing) data to the db in the background

Fields§

§backend: SharedBackend§cache_db: CacheDB<SharedBackend>§db: BlockchainDb§state_snapshots: Arc<Mutex<RawMutex, StateSnapshots<ForkDbStateSnapshot>>>

Struct ForkedDatabaseCopy item path

Fields§

Implementations§

impl ForkedDatabase

pub fn new(backend: SharedBackend, db: BlockchainDb) -> ForkedDatabase

pub fn database(&self) -> &CacheDB<SharedBackend>

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

pub fn state_snapshots( &self, ) -> &Arc<Mutex<RawMutex, StateSnapshots<ForkDbStateSnapshot>>>

pub fn reset( &mut self, _url: Option<String>, block_number: impl Into<BlockId>, ) -> Result<(), String>

pub fn flush_cache(&self)

pub fn inner(&self) -> &BlockchainDb

pub fn create_state_snapshot(&self) -> ForkDbStateSnapshot

pub fn insert_state_snapshot(&self) -> Uint<256, 4>

pub fn revert_state_snapshot( &mut self, id: Uint<256, 4>, action: RevertStateSnapshotAction, ) -> bool

Trait Implementations§

impl Clone for ForkedDatabase

fn clone(&self) -> ForkedDatabase

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

impl Database for ForkedDatabase

type Error = DatabaseError

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

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

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

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

impl DatabaseCommit for ForkedDatabase

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

impl DatabaseRef for ForkedDatabase

type Error = DatabaseError

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

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

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

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

impl Db for ForkedDatabase

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

fn set_storage_at( &mut self, address: Address, slot: B256, val: B256, ) -> DatabaseResult<()>

fn insert_block_hash(&mut self, number: U256, hash: B256)

fn dump_state( &self, at: BlockEnv, best_number: U64, blocks: Vec<SerializableBlock>, transactions: Vec<SerializableTransaction>, historical_states: Option<SerializableHistoricalStates>, ) -> DatabaseResult<Option<SerializableState>>

fn snapshot_state(&mut self) -> U256

fn revert_state(&mut self, id: U256, action: RevertStateSnapshotAction) -> bool

fn current_state(&self) -> StateDb

fn set_nonce(&mut self, address: Address, nonce: u64) -> DatabaseResult<()>

fn set_balance(&mut self, address: Address, balance: U256) -> DatabaseResult<()>

fn set_code(&mut self, address: Address, code: Bytes) -> DatabaseResult<()>

fn load_state(&mut self, state: SerializableState) -> DatabaseResult<bool>

fn maybe_state_root(&self) -> Option<B256>

impl Debug for ForkedDatabase

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

impl MaybeForkedDatabase for ForkedDatabase

fn maybe_reset( &mut self, url: Option<String>, block_number: BlockId, ) -> Result<(), String>

fn maybe_flush_cache(&self) -> Result<(), String>

fn maybe_inner(&self) -> Result<&BlockchainDb, String>

impl MaybeFullDatabase for ForkedDatabase

fn as_dyn(&self) -> &dyn DatabaseRef<Error = DatabaseError>

fn maybe_as_full_db(&self) -> Option<&HashMap<Address, DbAccount>>

fn clear_into_state_snapshot(&mut self) -> StateSnapshot

fn read_as_state_snapshot(&self) -> StateSnapshot

fn clear(&mut self)

fn init_from_state_snapshot(&mut self, state_snapshot: StateSnapshot)

Auto Trait Implementations§

impl Freeze for ForkedDatabase

impl !RefUnwindSafe for ForkedDatabase

impl Send for ForkedDatabase

impl Sync for ForkedDatabase

impl Unpin for ForkedDatabase

impl !UnwindSafe for ForkedDatabase

Blanket Implementations§

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dst: *mut u8)

impl<T, R> CollectAndApply<T, R> for T

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

type Output = R

impl<T> Conv for T

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

impl<T> DynClone for Twhere T: Clone,

Struct ForkedDatabase

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,