Struct DatabaseProviderRW

pub struct DatabaseProviderRW<DB, N>(pub DatabaseProvider<<DB as Database>::TXMut, N>)
where
    DB: Database,
    N: NodeTypes;

A DatabaseProvider that holds a read-write database transaction.

Ideally this would be an alias type. However, there’s some weird compiler error (https://github.com/rust-lang/rust/issues/102211), that forces us to wrap this in a struct instead. Once that issue is solved, we can probably revert back to being an alias type.

Tuple Fields

0: DatabaseProvider<<DB as Database>::TXMut, N>

Implementations

impl<DB, N> DatabaseProviderRW<DB, N>

where DB: Database, N: NodeTypes + 'static,

pub fn commit(self) -> Result<bool, ProviderError>

Commit database transaction and static file if it exists.

pub fn into_tx(self) -> <DB as Database>::TXMut

Consume DbTx or DbTxMut.

Methods from Deref<Target = DatabaseProvider<<DB as Database>::TXMut, N>>

pub fn prune_modes_ref(&self) -> &PruneModes

Returns reference to prune modes.

pub fn latest<'a>( &'a self, ) -> Result<Box<dyn StateProvider + 'a>, ProviderError>

State provider for latest block

pub fn history_by_block_hash<'a>( &'a self, block_hash: FixedBytes<32>, ) -> Result<Box<dyn StateProvider + 'a>, ProviderError>

Storage provider for state at that given block hash

pub fn unwind_trie_state_range( &self, range: RangeInclusive<u64>, ) -> Result<(), ProviderError>

Unwinds trie state for the given range.

This includes calculating the resulted state root and comparing it with the parent block state root.

pub fn insert_historical_block( &self, block: SealedBlockWithSenders<Header, <DatabaseProvider<Tx, N> as BlockWriter>::Body>, ) -> Result<StoredBlockBodyIndices, ProviderError>

Inserts an historical block. Used for setting up test environments

pub fn tx_mut(&mut self) -> &mut TX

Pass DbTx or DbTxMut mutable reference.

pub fn tx_ref(&self) -> &TX

Pass DbTx or DbTxMut immutable reference.

pub fn chain_spec(&self) -> &<N as NodeTypes>::ChainSpec

Returns a reference to the chain specification.

pub fn get_state( &self, range: RangeInclusive<u64>, ) -> Result<Option<ExecutionOutcome>, ProviderError>

Return the last N blocks of state, recreating the ExecutionOutcome.

1. Iterate over the BlockBodyIndices table to get all the transaction ids.
2. Iterate over the StorageChangeSets table and the AccountChangeSets tables in reverse order to reconstruct the changesets.
   • In order to have both the old and new values in the changesets, we also access the plain state tables.
3. While iterating over the changeset tables, if we encounter a new account or storage slot, we:
   1. Take the old value from the changeset
   2. Take the new value from the plain state
   3. Save the old value to the local state
4. While iterating over the changeset tables, if we encounter an account/storage slot we have seen before we:
   1. Take the old value from the changeset
   2. Take the new value from the local state
   3. Set the local state to the value in the changeset

If the range is empty, or there are no blocks for the given range, then this returns None.

Trait Implementations

impl<DB, N> AsRef<DatabaseProvider<<DB as Database>::TXMut, N>> for DatabaseProviderRW<DB, N>

where DB: Database, N: NodeTypes,

fn as_ref(&self) -> &DatabaseProvider<<DB as Database>::TXMut, N>

Converts this type into a shared reference of the (usually inferred) input type.

impl<DB, N> Debug for DatabaseProviderRW<DB, N>

where DB: Debug + Database, N: Debug + NodeTypes,

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

Formats the value using the given formatter.

impl<DB, N> Deref for DatabaseProviderRW<DB, N>

where DB: Database, N: NodeTypes,

type Target = DatabaseProvider<<DB as Database>::TXMut, N>

The resulting type after dereferencing.

fn deref(&self) -> &<DatabaseProviderRW<DB, N> as Deref>::Target

Dereferences the value.

impl<DB, N> DerefMut for DatabaseProviderRW<DB, N>

where DB: Database, N: NodeTypes,

fn deref_mut(&mut self) -> &mut <DatabaseProviderRW<DB, N> as Deref>::Target

Mutably dereferences the value.

impl<DB, N> From<DatabaseProviderRW<DB, N>> for DatabaseProvider<<DB as Database>::TXMut, N>

where DB: Database, N: NodeTypes,

fn from( provider: DatabaseProviderRW<DB, N>, ) -> DatabaseProvider<<DB as Database>::TXMut, N>

Converts to this type from the input type.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.