Struct DatabaseProvider

pub struct DatabaseProvider<TX, N>
where
    N: NodeTypes,
{ /* private fields */ }

A provider struct that fetches data from the database. Wrapper around DbTx and DbTxMut. Example: HeaderProvider BlockHashReader

Implementations

impl<TX, N> DatabaseProvider<TX, N>

where N: NodeTypes,

pub const fn prune_modes_ref(&self) -> &PruneModes

Returns reference to prune modes.

impl<TX, N> DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypes,

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

State provider for latest state

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 set_prune_modes(&mut self, prune_modes: PruneModes)

Available on crate feature test-utils only.

Sets the prune modes for provider.

impl<TX, N> DatabaseProvider<TX, N>

where TX: DbTxMut, N: NodeTypes,

pub const fn new_rw( tx: TX, chain_spec: Arc<<N as NodeTypes>::ChainSpec>, static_file_provider: StaticFileProvider<<N as NodeTypes>::Primitives>, prune_modes: PruneModes, storage: Arc<<N as NodeTypes>::Storage>, ) -> DatabaseProvider<TX, N>

Creates a provider with an inner read-write transaction.

impl<TX, N> DatabaseProvider<TX, N>

where TX: DbTx + DbTxMut + 'static, N: NodeTypesForProvider,

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.

impl<Tx, N> DatabaseProvider<Tx, N>

where Tx: DbTx + DbTxMut + 'static, N: NodeTypesForProvider, <N as NodeTypes>::Primitives: NodePrimitives<BlockHeader = Header>,

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

Inserts an historical block. Used for setting up test environments

impl<TX, N> DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypesForProvider,

pub const fn new( tx: TX, chain_spec: Arc<<N as NodeTypes>::ChainSpec>, static_file_provider: StaticFileProvider<<N as NodeTypes>::Primitives>, prune_modes: PruneModes, storage: Arc<<N as NodeTypes>::Storage>, ) -> DatabaseProvider<TX, N>

Creates a provider with an inner read-only transaction.

pub fn into_tx(self) -> TX

Consume DbTx or DbTxMut.

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

Pass DbTx or DbTxMut mutable reference.

pub const 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.

impl<TX, N> DatabaseProvider<TX, N>

where TX: DbTxMut + DbTx + 'static, N: NodeTypes,

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

Commit database transaction.

Trait Implementations

impl<TX, N> AccountExtReader for DatabaseProvider<TX, N>

where TX: DbTx, N: NodeTypes,

fn changed_accounts_with_range( &self, range: impl RangeBounds<u64>, ) -> Result<BTreeSet<Address>, ProviderError>

Iterate over account changesets and return all account address that were changed.

fn basic_accounts( &self, iter: impl IntoIterator<Item = Address>, ) -> Result<Vec<(Address, Option<Account>)>, ProviderError>

Get basic account information for multiple accounts. A more efficient version than calling AccountReader::basic_account repeatedly.

fn changed_accounts_and_blocks_with_range( &self, range: RangeInclusive<u64>, ) -> Result<BTreeMap<Address, Vec<u64>>, ProviderError>

Iterate over account changesets and return all account addresses that were changed alongside each specific set of blocks.

impl<TX, N> AccountReader for DatabaseProvider<TX, N>

where TX: DbTx, N: NodeTypes,

fn basic_account( &self, address: Address, ) -> Result<Option<Account>, ProviderError>

Get basic account information.

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<TX, N> AsRef<DatabaseProvider<TX, N>> for DatabaseProvider<TX, N>

where N: NodeTypes,

fn as_ref(&self) -> &DatabaseProvider<TX, N>

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

impl<TX, N> BlockBodyIndicesProvider for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypesForProvider,

fn block_body_indices( &self, num: u64, ) -> Result<Option<StoredBlockBodyIndices>, ProviderError>

Returns the block body indices with matching number from database.

impl<TX, N> BlockExecutionWriter for DatabaseProvider<TX, N>

where TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static,

fn take_block_and_execution_above( &self, block: u64, remove_from: StorageLocation, ) -> Result<Chain<<DatabaseProvider<TX, N> as NodePrimitivesProvider>::Primitives>, ProviderError>

Take all of the blocks above the provided number and their execution result

fn remove_block_and_execution_above( &self, block: u64, remove_from: StorageLocation, ) -> Result<(), ProviderError>

Remove all of the blocks above the provided number and their execution result

impl<TX, N> BlockHashReader for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypes,

fn block_hash( &self, number: u64, ) -> Result<Option<FixedBytes<32>>, ProviderError>

Get the hash of the block with the given number. Returns None if no block with this number exists.

fn canonical_hashes_range( &self, start: u64, end: u64, ) -> Result<Vec<FixedBytes<32>>, ProviderError>

Get headers in range of block hashes or numbers

fn convert_block_hash( &self, hash_or_number: HashOrNumber, ) -> Result<Option<FixedBytes<32>>, ProviderError>

Get the hash of the block with the given number. Returns None if no block with this number exists.

impl<TX, N> BlockNumReader for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypes,

fn chain_info(&self) -> Result<ChainInfo, ProviderError>

Returns the current info for the chain.

fn best_block_number(&self) -> Result<u64, ProviderError>

Returns the best block number in the chain.

fn last_block_number(&self) -> Result<u64, ProviderError>

Returns the last block number associated with the last canonical header in the database.

fn block_number( &self, hash: FixedBytes<32>, ) -> Result<Option<u64>, ProviderError>

Gets the BlockNumber for the given hash. Returns None if no block with this hash exists.

fn convert_hash_or_number( &self, id: HashOrNumber, ) -> Result<Option<u64>, ProviderError>

Gets the block number for the given BlockHashOrNumber. Returns None if no block with this hash exists. If the BlockHashOrNumber is a Number, it is returned as is.

fn convert_number( &self, id: HashOrNumber, ) -> Result<Option<FixedBytes<32>>, ProviderError>

Gets the block hash for the given BlockHashOrNumber. Returns None if no block with this number exists. If the BlockHashOrNumber is a Hash, it is returned as is.

impl<TX, N> BlockReader for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypesForProvider,

fn block( &self, id: HashOrNumber, ) -> Result<Option<<DatabaseProvider<TX, N> as BlockReader>::Block>, ProviderError>

Returns the block with matching number from database.

If the header for this block is not found, this returns None. If the header is found, but the transactions either do not exist, or are not indexed, this will return None.

fn block_with_senders( &self, id: HashOrNumber, transaction_kind: TransactionVariant, ) -> Result<Option<BlockWithSenders<<DatabaseProvider<TX, N> as BlockReader>::Block>>, ProviderError>

Returns the block with senders with matching number or hash from database.

NOTE: The transactions have invalid hashes, since they would need to be calculated on the spot, and we want fast querying.

If the header for this block is not found, this returns None. If the header is found, but the transactions either do not exist, or are not indexed, this will return None.

type Block = <<N as NodeTypes>::Primitives as NodePrimitives>::Block

The block type this provider reads.

fn find_block_by_hash( &self, hash: FixedBytes<32>, source: BlockSource, ) -> Result<Option<<DatabaseProvider<TX, N> as BlockReader>::Block>, ProviderError>

Tries to find in the given block source.

fn pending_block( &self, ) -> Result<Option<SealedBlock<<<DatabaseProvider<TX, N> as BlockReader>::Block as Block>::Header, <<DatabaseProvider<TX, N> as BlockReader>::Block as Block>::Body>>, ProviderError>

Returns the pending block if available

fn pending_block_with_senders( &self, ) -> Result<Option<SealedBlockWithSenders<<DatabaseProvider<TX, N> as BlockReader>::Block>>, ProviderError>

Returns the pending block if available

fn pending_block_and_receipts( &self, ) -> Result<Option<(SealedBlock<<<DatabaseProvider<TX, N> as BlockReader>::Block as Block>::Header, <<DatabaseProvider<TX, N> as BlockReader>::Block as Block>::Body>, Vec<<DatabaseProvider<TX, N> as ReceiptProvider>::Receipt>)>, ProviderError>

Returns the pending block and receipts if available.

fn sealed_block_with_senders( &self, id: HashOrNumber, transaction_kind: TransactionVariant, ) -> Result<Option<SealedBlockWithSenders<<DatabaseProvider<TX, N> as BlockReader>::Block>>, ProviderError>

Returns the sealed block with senders with matching number or hash from database.

fn block_range( &self, range: RangeInclusive<u64>, ) -> Result<Vec<<DatabaseProvider<TX, N> as BlockReader>::Block>, ProviderError>

Returns all blocks in the given inclusive range.

fn block_with_senders_range( &self, range: RangeInclusive<u64>, ) -> Result<Vec<BlockWithSenders<<DatabaseProvider<TX, N> as BlockReader>::Block>>, ProviderError>

Returns a range of blocks from the database, along with the senders of each transaction in the blocks.

fn sealed_block_with_senders_range( &self, range: RangeInclusive<u64>, ) -> Result<Vec<SealedBlockWithSenders<<DatabaseProvider<TX, N> as BlockReader>::Block>>, ProviderError>

Returns a range of sealed blocks from the database, along with the senders of each transaction in the blocks.

fn block_by_hash( &self, hash: FixedBytes<32>, ) -> Result<Option<Self::Block>, ProviderError>

Returns the block with matching hash from the database.

fn block_by_number( &self, num: u64, ) -> Result<Option<Self::Block>, ProviderError>

Returns the block with matching number from database.

impl<TX, N> BlockWriter for DatabaseProvider<TX, N>

where TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static,

fn insert_block( &self, block: SealedBlockWithSenders<<DatabaseProvider<TX, N> as BlockWriter>::Block>, write_to: StorageLocation, ) -> Result<StoredBlockBodyIndices, ProviderError>

Inserts the block into the database, always modifying the following tables:

• CanonicalHeaders
• Headers
• HeaderNumbers
• HeaderTerminalDifficulties
• BlockBodyIndices

If there are transactions in the block, the following tables will be modified:

• Transactions
• TransactionBlocks

If ommers are not empty, this will modify BlockOmmers. If withdrawals are not empty, this will modify BlockWithdrawals.

If the provider has not configured full sender pruning, this will modify TransactionSenders.

If the provider has not configured full transaction lookup pruning, this will modify TransactionHashNumbers.

fn append_blocks_with_state( &self, blocks: Vec<SealedBlockWithSenders<<DatabaseProvider<TX, N> as BlockWriter>::Block>>, execution_outcome: ExecutionOutcome<<DatabaseProvider<TX, N> as BlockWriter>::Receipt>, hashed_state: HashedPostStateSorted, trie_updates: TrieUpdates, ) -> Result<(), ProviderError>

TODO(joshie): this fn should be moved to UnifiedStorageWriter eventually

type Block = <<N as NodeTypes>::Primitives as NodePrimitives>::Block

The body this writer can write.

type Receipt = <<N as NodeTypes>::Primitives as NodePrimitives>::Receipt

The receipt type for ExecutionOutcome.

fn append_block_bodies( &self, bodies: Vec<(u64, Option<<<N as NodeTypes>::Primitives as NodePrimitives>::BlockBody>)>, write_to: StorageLocation, ) -> Result<(), ProviderError>

Appends a batch of block bodies extending the canonical chain. This is invoked during Bodies stage and does not write to TransactionHashNumbers and TransactionSenders tables which are populated on later stages.

fn remove_blocks_above( &self, block: u64, remove_from: StorageLocation, ) -> Result<(), ProviderError>

Removes all blocks above the given block number from the database.

fn remove_bodies_above( &self, block: u64, remove_from: StorageLocation, ) -> Result<(), ProviderError>

Removes all block bodies above the given block number from the database.

impl<TX, N> ChainSpecProvider for DatabaseProvider<TX, N>

where TX: Send + Sync, N: NodeTypes, <N as NodeTypes>::ChainSpec: EthChainSpec + 'static,

type ChainSpec = <N as NodeTypes>::ChainSpec

The chain spec type.

fn chain_spec( &self, ) -> Arc<<DatabaseProvider<TX, N> as ChainSpecProvider>::ChainSpec>

Get an Arc to the chainspec.

impl<TX, N> ChainStateBlockReader for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypes,

fn last_finalized_block_number(&self) -> Result<Option<u64>, ProviderError>

Returns the last finalized block number.

fn last_safe_block_number(&self) -> Result<Option<u64>, ProviderError>

Returns the last safe block number.

impl<TX, N> ChainStateBlockWriter for DatabaseProvider<TX, N>

where TX: DbTxMut, N: NodeTypes,

fn save_finalized_block_number( &self, block_number: u64, ) -> Result<(), ProviderError>

Saves the given finalized block number in the DB.

fn save_safe_block_number(&self, block_number: u64) -> Result<(), ProviderError>

Saves the given safe block number in the DB.

impl<TX, N> ChangeSetReader for DatabaseProvider<TX, N>

where TX: DbTx, N: NodeTypes,

fn account_block_changeset( &self, block_number: u64, ) -> Result<Vec<AccountBeforeTx>, ProviderError>

Iterate over account changesets and return the account state from before this block.

impl<TX, N> DBProvider for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypes + 'static,

type Tx = TX

Underlying database transaction held by the provider.

fn tx_ref(&self) -> &<DatabaseProvider<TX, N> as DBProvider>::Tx

Returns a reference to the underlying transaction.

fn tx_mut(&mut self) -> &mut <DatabaseProvider<TX, N> as DBProvider>::Tx

Returns a mutable reference to the underlying transaction.

fn into_tx(self) -> <DatabaseProvider<TX, N> as DBProvider>::Tx

Consumes the provider and returns the underlying transaction.

fn prune_modes_ref(&self) -> &PruneModes

Returns a reference to prune modes.

fn disable_long_read_transaction_safety(self) -> Self

Disables long-lived read transaction safety guarantees for leaks prevention and observability improvements.

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

Commit database transaction

fn table<T>( &self, ) -> Result<Vec<(<T as Table>::Key, <T as Table>::Value)>, DatabaseError>

where T: Table, <T as Table>::Key: Default + Ord,

Return full table as Vec

fn get<T>( &self, range: impl RangeBounds<<T as Table>::Key>, ) -> Result<Vec<(<T as Table>::Key, <T as Table>::Value)>, DatabaseError>

where T: Table,

Return a list of entries from the table, based on the given range.

fn cursor_read_collect<T>( &self, range: impl RangeBounds<<T as Table>::Key>, ) -> Result<Vec<<T as Table>::Value>, ProviderError>

where T: Table<Key = u64>,

Iterates over read only values in the given table and collects them into a vector.

fn cursor_collect<T>( &self, cursor: &mut impl DbCursorRO<T>, range: impl RangeBounds<<T as Table>::Key>, ) -> Result<Vec<<T as Table>::Value>, ProviderError>

where T: Table<Key = u64>,

Iterates over read only values in the given table and collects them into a vector.

fn cursor_collect_with_capacity<T>( &self, cursor: &mut impl DbCursorRO<T>, range: impl RangeBounds<<T as Table>::Key>, capacity: usize, ) -> Result<Vec<<T as Table>::Value>, ProviderError>

where T: Table<Key = u64>,

Iterates over read only values in the given table and collects them into a vector with capacity.

fn remove<T>( &self, range: impl RangeBounds<<T as Table>::Key>, ) -> Result<usize, DatabaseError>

where T: Table, Self::Tx: DbTxMut,

Remove list of entries from the table. Returns the number of entries removed.

fn take<T>( &self, range: impl RangeBounds<<T as Table>::Key>, ) -> Result<Vec<(<T as Table>::Key, <T as Table>::Value)>, DatabaseError>

where T: Table, Self::Tx: DbTxMut,

Return a list of entries from the table, and remove them, based on the given range.

impl<TX, N> Debug for DatabaseProvider<TX, N>

where TX: Debug, N: Debug + NodeTypes, <N as NodeTypes>::ChainSpec: Debug, <N as NodeTypes>::Primitives: Debug, <N as NodeTypes>::Storage: Debug,

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

Formats the value using the given formatter.

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.

impl<TX, N> HashingWriter for DatabaseProvider<TX, N>

where TX: DbTxMut + DbTx + 'static, N: NodeTypes,

fn unwind_account_hashing<'a>( &self, changesets: impl Iterator<Item = &'a (u64, AccountBeforeTx)>, ) -> Result<BTreeMap<FixedBytes<32>, Option<Account>>, ProviderError>

Unwind and clear account hashing.

fn unwind_account_hashing_range( &self, range: impl RangeBounds<u64>, ) -> Result<BTreeMap<FixedBytes<32>, Option<Account>>, ProviderError>

Unwind and clear account hashing in a given block range.

fn insert_account_for_hashing( &self, changesets: impl IntoIterator<Item = (Address, Option<Account>)>, ) -> Result<BTreeMap<FixedBytes<32>, Option<Account>>, ProviderError>

Inserts all accounts into reth_db::tables::AccountsHistory table.

fn unwind_storage_hashing( &self, changesets: impl Iterator<Item = (BlockNumberAddress, StorageEntry)>, ) -> Result<HashMap<FixedBytes<32>, BTreeSet<FixedBytes<32>>, RandomState>, ProviderError>

Unwind and clear storage hashing

fn unwind_storage_hashing_range( &self, range: impl RangeBounds<BlockNumberAddress>, ) -> Result<HashMap<FixedBytes<32>, BTreeSet<FixedBytes<32>>, RandomState>, ProviderError>

Unwind and clear storage hashing in a given block range.

fn insert_storage_for_hashing( &self, storages: impl IntoIterator<Item = (Address, impl IntoIterator<Item = StorageEntry>)>, ) -> Result<HashMap<FixedBytes<32>, BTreeSet<FixedBytes<32>>, RandomState>, ProviderError>

Iterates over storages and inserts them to hashing table.

fn insert_hashes( &self, range: RangeInclusive<u64>, end_block_hash: FixedBytes<32>, expected_state_root: FixedBytes<32>, ) -> Result<(), ProviderError>

Calculate the hashes of all changed accounts and storages, and finally calculate the state root.

impl<TX, N> HeaderProvider for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypesForProvider,

type Header = <<N as NodeTypes>::Primitives as NodePrimitives>::BlockHeader

The header type this provider supports.

fn header( &self, block_hash: &FixedBytes<32>, ) -> Result<Option<<DatabaseProvider<TX, N> as HeaderProvider>::Header>, ProviderError>

Get header by block hash

fn header_by_number( &self, num: u64, ) -> Result<Option<<DatabaseProvider<TX, N> as HeaderProvider>::Header>, ProviderError>

Get header by block number

fn header_td( &self, block_hash: &FixedBytes<32>, ) -> Result<Option<Uint<256, 4>>, ProviderError>

Get total difficulty by block hash.

fn header_td_by_number( &self, number: u64, ) -> Result<Option<Uint<256, 4>>, ProviderError>

Get total difficulty by block number.

fn headers_range( &self, range: impl RangeBounds<u64>, ) -> Result<Vec<<DatabaseProvider<TX, N> as HeaderProvider>::Header>, ProviderError>

Get headers in range of block numbers

fn sealed_header( &self, number: u64, ) -> Result<Option<SealedHeader<<DatabaseProvider<TX, N> as HeaderProvider>::Header>>, ProviderError>

Get a single sealed header by block number.

fn sealed_headers_while( &self, range: impl RangeBounds<u64>, predicate: impl FnMut(&SealedHeader<<DatabaseProvider<TX, N> as HeaderProvider>::Header>) -> bool, ) -> Result<Vec<SealedHeader<<DatabaseProvider<TX, N> as HeaderProvider>::Header>>, ProviderError>

Get sealed headers while predicate returns true or the range is exhausted.

fn is_known(&self, block_hash: &FixedBytes<32>) -> Result<bool, ProviderError>

Check if block is known

fn sealed_header_by_hash( &self, block_hash: FixedBytes<32>, ) -> Result<Option<SealedHeader<Self::Header>>, ProviderError>

Retrieves the header sealed by the given block hash.

fn header_by_hash_or_number( &self, hash_or_num: HashOrNumber, ) -> Result<Option<Self::Header>, ProviderError>

Get header by block number or hash

fn sealed_headers_range( &self, range: impl RangeBounds<u64>, ) -> Result<Vec<SealedHeader<Self::Header>>, ProviderError>

Get headers in range of block numbers.

impl<TX, N> HeaderSyncGapProvider for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypesForProvider,

type Header = <<N as NodeTypes>::Primitives as NodePrimitives>::BlockHeader

The header type.

fn sync_gap( &self, tip: Receiver<FixedBytes<32>>, highest_uninterrupted_block: u64, ) -> Result<HeaderSyncGap<<DatabaseProvider<TX, N> as HeaderSyncGapProvider>::Header>, ProviderError>

Find a current sync gap for the headers depending on the last uninterrupted block number. Last uninterrupted block represents the block number before which there are no gaps. It’s up to the caller to ensure that last uninterrupted block is determined correctly.

impl<TX, N> HistoryWriter for DatabaseProvider<TX, N>

where TX: DbTxMut + DbTx + 'static, N: NodeTypes,

fn unwind_account_history_indices<'a>( &self, changesets: impl Iterator<Item = &'a (u64, AccountBeforeTx)>, ) -> Result<usize, ProviderError>

Unwind and clear account history indices.

fn unwind_account_history_indices_range( &self, range: impl RangeBounds<u64>, ) -> Result<usize, ProviderError>

Unwind and clear account history indices in a given block range.

fn insert_account_history_index( &self, account_transitions: impl IntoIterator<Item = (Address, impl IntoIterator<Item = u64>)>, ) -> Result<(), ProviderError>

Insert account change index to database. Used inside AccountHistoryIndex stage

fn unwind_storage_history_indices( &self, changesets: impl Iterator<Item = (BlockNumberAddress, StorageEntry)>, ) -> Result<usize, ProviderError>

Unwind and clear storage history indices.

fn unwind_storage_history_indices_range( &self, range: impl RangeBounds<BlockNumberAddress>, ) -> Result<usize, ProviderError>

Unwind and clear storage history indices in a given block range.

fn insert_storage_history_index( &self, storage_transitions: impl IntoIterator<Item = ((Address, FixedBytes<32>), impl IntoIterator<Item = u64>)>, ) -> Result<(), ProviderError>

Insert storage change index to database. Used inside StorageHistoryIndex stage

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

Read account/storage changesets and update account/storage history indices.

impl<TX, N> NodePrimitivesProvider for DatabaseProvider<TX, N>

where N: NodeTypes,

type Primitives = <N as NodeTypes>::Primitives

The node primitive types.

impl<TX, N> OmmersProvider for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypesForProvider,

fn ommers( &self, id: HashOrNumber, ) -> Result<Option<Vec<<DatabaseProvider<TX, N> as HeaderProvider>::Header>>, ProviderError>

Returns the ommers for the block with matching id from the database.

If the block is not found, this returns None. If the block exists, but doesn’t contain ommers, this returns None.

impl<TX, N> PruneCheckpointReader for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypes,

fn get_prune_checkpoint( &self, segment: PruneSegment, ) -> Result<Option<PruneCheckpoint>, ProviderError>

Fetch the prune checkpoint for the given segment.

fn get_prune_checkpoints( &self, ) -> Result<Vec<(PruneSegment, PruneCheckpoint)>, ProviderError>

Fetch all the prune checkpoints.

impl<TX, N> PruneCheckpointWriter for DatabaseProvider<TX, N>

where TX: DbTxMut, N: NodeTypes,

fn save_prune_checkpoint( &self, segment: PruneSegment, checkpoint: PruneCheckpoint, ) -> Result<(), ProviderError>

Save prune checkpoint.

impl<TX, N> ReceiptProvider for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypesForProvider,

type Receipt = <<N as NodeTypes>::Primitives as NodePrimitives>::Receipt

The receipt type.

fn receipt( &self, id: u64, ) -> Result<Option<<DatabaseProvider<TX, N> as ReceiptProvider>::Receipt>, ProviderError>

Get receipt by transaction number

fn receipt_by_hash( &self, hash: FixedBytes<32>, ) -> Result<Option<<DatabaseProvider<TX, N> as ReceiptProvider>::Receipt>, ProviderError>

Get receipt by transaction hash.

fn receipts_by_block( &self, block: HashOrNumber, ) -> Result<Option<Vec<<DatabaseProvider<TX, N> as ReceiptProvider>::Receipt>>, ProviderError>

Get receipts by block num or hash.

fn receipts_by_tx_range( &self, range: impl RangeBounds<u64>, ) -> Result<Vec<<DatabaseProvider<TX, N> as ReceiptProvider>::Receipt>, ProviderError>

Get receipts by tx range.

impl<TX, N> StageCheckpointReader for DatabaseProvider<TX, N>

where TX: DbTx, N: NodeTypes,

fn get_stage_checkpoint_progress( &self, id: StageId, ) -> Result<Option<Vec<u8>>, ProviderError>

Get stage checkpoint progress.

fn get_stage_checkpoint( &self, id: StageId, ) -> Result<Option<StageCheckpoint>, ProviderError>

Fetch the checkpoint for the given stage.

fn get_all_checkpoints( &self, ) -> Result<Vec<(String, StageCheckpoint)>, ProviderError>

Reads all stage checkpoints and returns a list with the name of the stage and the checkpoint data.

impl<TX, N> StageCheckpointWriter for DatabaseProvider<TX, N>

where TX: DbTxMut, N: NodeTypes,

fn save_stage_checkpoint( &self, id: StageId, checkpoint: StageCheckpoint, ) -> Result<(), ProviderError>

Save stage checkpoint.

fn save_stage_checkpoint_progress( &self, id: StageId, checkpoint: Vec<u8>, ) -> Result<(), ProviderError>

Save stage checkpoint progress.

fn update_pipeline_stages( &self, block_number: u64, drop_stage_checkpoint: bool, ) -> Result<(), ProviderError>

Update all pipeline sync stage progress.

impl<TX, N> StateCommitmentProvider for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypes,

type StateCommitment = <N as NodeTypes>::StateCommitment

The [StateCommitment] type that can be used to perform state commitment operations.

impl<TX, N> StateWriter for DatabaseProvider<TX, N>

where TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider,

fn remove_state_above( &self, block: u64, remove_receipts_from: StorageLocation, ) -> Result<(), ProviderError>

Remove the last N blocks of state.

The latest state will be unwound

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

fn take_state_above( &self, block: u64, remove_receipts_from: StorageLocation, ) -> Result<ExecutionOutcome<<DatabaseProvider<TX, N> as StateWriter>::Receipt>, ProviderError>

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

The latest state will be unwound and returned back with all the blocks

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

type Receipt = <<N as NodeTypes>::Primitives as NodePrimitives>::Receipt

Receipt type included into ExecutionOutcome.

fn write_state( &self, execution_outcome: ExecutionOutcome<<DatabaseProvider<TX, N> as StateWriter>::Receipt>, is_value_known: OriginalValuesKnown, write_receipts_to: StorageLocation, ) -> Result<(), ProviderError>

Write the state and receipts to the database or static files if static_file_producer is Some. It should be None if there is any kind of pruning/filtering over the receipts.

fn write_state_reverts( &self, reverts: PlainStateReverts, first_block: u64, ) -> Result<(), ProviderError>

Write state reverts to the database.

fn write_state_changes( &self, changes: StateChangeset, ) -> Result<(), ProviderError>

Write state changes to the database.

fn write_hashed_state( &self, hashed_state: &HashedPostStateSorted, ) -> Result<(), ProviderError>

Writes the hashed state changes to the database

impl<TX, N> StaticFileProviderFactory for DatabaseProvider<TX, N>

where N: NodeTypes,

fn static_file_provider( &self, ) -> StaticFileProvider<<DatabaseProvider<TX, N> as NodePrimitivesProvider>::Primitives>

Returns a static file provider

impl<TX, N> StatsReader for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypesForProvider,

fn count_entries<T>(&self) -> Result<usize, ProviderError>

where T: Table,

Fetch the number of entries in the corresponding Table. Depending on the provider, it may route to different data sources other than Table.

impl<TX, N> StorageChangeSetReader for DatabaseProvider<TX, N>

where TX: DbTx, N: NodeTypes,

fn storage_changeset( &self, block_number: u64, ) -> Result<Vec<(BlockNumberAddress, StorageEntry)>, ProviderError>

Iterate over storage changesets and return the storage state from before this block.

impl<TX, N> StorageReader for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypes,

fn plain_state_storages( &self, addresses_with_keys: impl IntoIterator<Item = (Address, impl IntoIterator<Item = FixedBytes<32>>)>, ) -> Result<Vec<(Address, Vec<StorageEntry>)>, ProviderError>

Get plainstate storages for addresses and storage keys.

fn changed_storages_with_range( &self, range: RangeInclusive<u64>, ) -> Result<BTreeMap<Address, BTreeSet<FixedBytes<32>>>, ProviderError>

Iterate over storage changesets and return all storage slots that were changed.

fn changed_storages_and_blocks_with_range( &self, range: RangeInclusive<u64>, ) -> Result<BTreeMap<(Address, FixedBytes<32>), Vec<u64>>, ProviderError>

Iterate over storage changesets and return all storage slots that were changed alongside each specific set of blocks.

impl<TX, N> StorageTrieWriter for DatabaseProvider<TX, N>

where TX: DbTxMut + DbTx + 'static, N: NodeTypes,

fn write_storage_trie_updates( &self, storage_tries: &HashMap<FixedBytes<32>, StorageTrieUpdates, FbBuildHasher<32>>, ) -> Result<usize, ProviderError>

Writes storage trie updates from the given storage trie map. First sorts the storage trie updates by the hashed address, writing in sorted order.

fn write_individual_storage_trie_updates( &self, hashed_address: FixedBytes<32>, updates: &StorageTrieUpdates, ) -> Result<usize, ProviderError>

Writes storage trie updates for the given hashed address.

impl<TX, N> TransactionsProvider for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypesForProvider,

type Transaction = <<N as NodeTypes>::Primitives as NodePrimitives>::SignedTx

The transaction type this provider reads.

fn transaction_id( &self, tx_hash: FixedBytes<32>, ) -> Result<Option<u64>, ProviderError>

Get internal transaction identifier by transaction hash.

fn transaction_by_id( &self, id: u64, ) -> Result<Option<<DatabaseProvider<TX, N> as TransactionsProvider>::Transaction>, ProviderError>

Get transaction by id, computes hash every time so more expensive.

fn transaction_by_id_unhashed( &self, id: u64, ) -> Result<Option<<DatabaseProvider<TX, N> as TransactionsProvider>::Transaction>, ProviderError>

Get transaction by id without computing the hash.

fn transaction_by_hash( &self, hash: FixedBytes<32>, ) -> Result<Option<<DatabaseProvider<TX, N> as TransactionsProvider>::Transaction>, ProviderError>

Get transaction by transaction hash.

fn transaction_by_hash_with_meta( &self, tx_hash: FixedBytes<32>, ) -> Result<Option<(<DatabaseProvider<TX, N> as TransactionsProvider>::Transaction, TransactionMeta)>, ProviderError>

Get transaction by transaction hash and additional metadata of the block the transaction was mined in

fn transaction_block(&self, id: u64) -> Result<Option<u64>, ProviderError>

Get transaction block number

fn transactions_by_block( &self, id: HashOrNumber, ) -> Result<Option<Vec<<DatabaseProvider<TX, N> as TransactionsProvider>::Transaction>>, ProviderError>

Get transactions by block id.

fn transactions_by_block_range( &self, range: impl RangeBounds<u64>, ) -> Result<Vec<Vec<<DatabaseProvider<TX, N> as TransactionsProvider>::Transaction>>, ProviderError>

Get transactions by block range.

fn transactions_by_tx_range( &self, range: impl RangeBounds<u64>, ) -> Result<Vec<<DatabaseProvider<TX, N> as TransactionsProvider>::Transaction>, ProviderError>

Get transactions by tx range.

fn senders_by_tx_range( &self, range: impl RangeBounds<u64>, ) -> Result<Vec<Address>, ProviderError>

Get Senders from a tx range.

fn transaction_sender(&self, id: u64) -> Result<Option<Address>, ProviderError>

Get transaction sender.

impl<TX, N> TransactionsProviderExt for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypesForProvider,

fn transaction_hashes_by_range( &self, tx_range: Range<u64>, ) -> Result<Vec<(FixedBytes<32>, u64)>, ProviderError>

Recovers transaction hashes by walking through Transactions table and calculating them in a parallel manner. Returned unsorted.

fn transaction_range_by_block_range( &self, block_range: RangeInclusive<u64>, ) -> Result<RangeInclusive<u64>, ProviderError>

Get transactions range by block range.

impl<TX, N> TrieWriter for DatabaseProvider<TX, N>

where TX: DbTxMut + DbTx + 'static, N: NodeTypes,

fn write_trie_updates( &self, trie_updates: &TrieUpdates, ) -> Result<usize, ProviderError>

Writes trie updates. Returns the number of entries modified.

impl<TX, N> TryIntoHistoricalStateProvider for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypes,

fn try_into_history_at_block( self, block_number: u64, ) -> Result<Box<dyn StateProvider>, ProviderError>

Returns a historical StateProvider indexed by the given historic block number.

impl<TX, N> WithdrawalsProvider for DatabaseProvider<TX, N>

where TX: DbTx + 'static, N: NodeTypes, <N as NodeTypes>::ChainSpec: EthereumHardforks,

fn withdrawals_by_block( &self, id: HashOrNumber, timestamp: u64, ) -> Result<Option<Withdrawals>, ProviderError>

Get withdrawals by block id.

fn latest_withdrawal(&self) -> Result<Option<Withdrawal>, ProviderError>

Get latest withdrawal from this block or earlier .

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.