Struct reth_provider::providers::DatabaseProvider

pub struct DatabaseProvider<TX> { /* private fields */ }

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

Implementations

impl<TX> DatabaseProvider<TX>

pub const fn static_file_provider(&self) -> &StaticFileProvider

Returns a static file provider

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

Returns reference to prune modes.

impl<TX: DbTxMut> DatabaseProvider<TX>

pub const fn new_rw( tx: TX, chain_spec: Arc<ChainSpec>, static_file_provider: StaticFileProvider, prune_modes: PruneModes, ) -> Self

Creates a provider with an inner read-write transaction.

impl<TX: DbTx> DatabaseProvider<TX>

pub const fn new( tx: TX, chain_spec: Arc<ChainSpec>, static_file_provider: StaticFileProvider, prune_modes: PruneModes, ) -> Self

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) -> &ChainSpec

Returns a reference to the [ChainSpec].

pub fn disable_long_read_transaction_safety(self) -> Self

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

CAUTION: In most of the cases, you want the safety guarantees for long read transactions enabled. Use this only if you’re sure that no write transaction is open in parallel, meaning that Reth as a node is offline and not progressing.

pub fn table<T: Table>(&self) -> Result<Vec<KeyValue<T>>, DatabaseError>

where T::Key: Default + Ord,

Return full table as Vec

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

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

pub fn get_block_range( &self, range: impl RangeBounds<BlockNumber> + Clone, ) -> ProviderResult<Vec<SealedBlockWithSenders>>

Get the given range of blocks.

pub fn get_state( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<Option<ExecutionOutcome>>

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.

impl<TX: DbTxMut + DbTx> DatabaseProvider<TX>

pub fn commit(self) -> ProviderResult<bool>

Commit database transaction.

pub fn remove_state( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<()>

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

pub fn take_state( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<ExecutionOutcome>

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

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

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

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

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

pub fn remove_block_transaction_range( &self, range: impl RangeBounds<BlockNumber> + Clone, ) -> ProviderResult<()>

Remove requested block transactions, without returning them.

This will remove block data for the given range from the following tables:

• BlockBodyIndices
• Transactions
• TransactionSenders
• TransactionHashNumbers
• TransactionBlocks

pub fn take_block_transaction_range( &self, range: impl RangeBounds<BlockNumber> + Clone, ) -> ProviderResult<Vec<(BlockNumber, Vec<TransactionSignedEcRecovered>)>>

Get requested blocks transaction with senders, also removing them from the database

This will remove block data for the given range from the following tables:

• BlockBodyIndices
• Transactions
• TransactionSenders
• TransactionHashNumbers
• TransactionBlocks

pub fn remove_block_range( &self, range: impl RangeBounds<BlockNumber> + Clone, ) -> ProviderResult<()>

Remove the given range of blocks, without returning any of the blocks.

This will remove block data for the given range from the following tables:

• HeaderNumbers
• CanonicalHeaders
• BlockOmmers
• BlockWithdrawals
• BlockRequests
• HeaderTerminalDifficulties

This will also remove transaction data according to remove_block_transaction_range.

pub fn take_block_range( &self, range: impl RangeBounds<BlockNumber> + Clone, ) -> ProviderResult<Vec<SealedBlockWithSenders>>

Remove the given range of blocks, and return them.

This will remove block data for the given range from the following tables:

• HeaderNumbers
• CanonicalHeaders
• BlockOmmers
• BlockWithdrawals
• BlockRequests
• HeaderTerminalDifficulties

This will also remove transaction data according to take_block_transaction_range.

pub fn unwind_table_by_num<T>(&self, num: u64) -> Result<usize, DatabaseError>

where T: Table<Key = u64>,

Unwind table by some number key. Returns number of rows unwound.

Note: Key is not inclusive and specified key would stay in db.

pub fn unwind_table_by_walker<T1, T2>( &self, range: impl RangeBounds<T1::Key>, ) -> Result<(), DatabaseError>

where T1: Table, T2: Table<Key = T1::Value>,

Unwind a table forward by a [Walker][reth_db_api::cursor::Walker] on another table.

Note: Range is inclusive and first key in the range is removed.

Trait Implementations

impl<TX: DbTx> AccountExtReader for DatabaseProvider<TX>

fn changed_accounts_with_range( &self, range: impl RangeBounds<BlockNumber>, ) -> ProviderResult<BTreeSet<Address>>

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

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

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<BlockNumber>, ) -> ProviderResult<BTreeMap<Address, Vec<u64>>>

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

impl<TX: DbTx> AccountReader for DatabaseProvider<TX>

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

Get basic account information.

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

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

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

impl<TX> AsRef<DatabaseProvider<TX>> for DatabaseProvider<TX>

fn as_ref(&self) -> &Self

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

impl<TX: DbTx> BlockExecutionReader for DatabaseProvider<TX>

fn get_block_and_execution_range( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<Chain>

Get range of blocks and its execution result

impl<TX: DbTxMut + DbTx + 'static> BlockExecutionWriter for DatabaseProvider<TX>

fn take_block_and_execution_range( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<Chain>

Take range of blocks and its execution result

fn remove_block_and_execution_range( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<()>

Remove range of blocks and its execution result

impl<TX: DbTx> BlockHashReader for DatabaseProvider<TX>

fn block_hash(&self, number: u64) -> ProviderResult<Option<B256>>

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: BlockNumber, end: BlockNumber, ) -> ProviderResult<Vec<B256>>

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: DbTx> BlockNumReader for DatabaseProvider<TX>

fn chain_info(&self) -> ProviderResult<ChainInfo>

Returns the current info for the chain.

fn best_block_number(&self) -> ProviderResult<BlockNumber>

Returns the best block number in the chain.

fn last_block_number(&self) -> ProviderResult<BlockNumber>

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

fn block_number(&self, hash: B256) -> ProviderResult<Option<BlockNumber>>

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: DbTx> BlockReader for DatabaseProvider<TX>

fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Block>>

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 ommers(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Vec<Header>>>

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.

fn block_with_senders( &self, id: BlockHashOrNumber, transaction_kind: TransactionVariant, ) -> ProviderResult<Option<BlockWithSenders>>

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.

fn find_block_by_hash( &self, hash: B256, source: BlockSource, ) -> ProviderResult<Option<Block>>

Tries to find in the given block source.

fn pending_block(&self) -> ProviderResult<Option<SealedBlock>>

Returns the pending block if available

fn pending_block_with_senders( &self, ) -> ProviderResult<Option<SealedBlockWithSenders>>

Returns the pending block if available

fn pending_block_and_receipts( &self, ) -> ProviderResult<Option<(SealedBlock, Vec<Receipt>)>>

Returns the pending block and receipts if available.

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

Returns the block body indices with matching number from database.

fn sealed_block_with_senders( &self, id: BlockHashOrNumber, transaction_kind: TransactionVariant, ) -> ProviderResult<Option<SealedBlockWithSenders>>

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

fn block_range( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<Vec<Block>>

Returns all blocks in the given inclusive range.

fn block_with_senders_range( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<Vec<BlockWithSenders>>

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<BlockNumber>, ) -> ProviderResult<Vec<SealedBlockWithSenders>>

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<Block>, ProviderError>

Returns the block with matching hash from the database.

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

Returns the block with matching number from database.

impl<TX: DbTxMut + DbTx + 'static> BlockWriter for DatabaseProvider<TX>

fn insert_block( &self, block: SealedBlockWithSenders, ) -> ProviderResult<StoredBlockBodyIndices>

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 requests are not empty, this will modify BlockRequests.

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>, execution_outcome: ExecutionOutcome, hashed_state: HashedPostStateSorted, trie_updates: TrieUpdates, ) -> ProviderResult<()>

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

impl<TX: DbTx> ChangeSetReader for DatabaseProvider<TX>

fn account_block_changeset( &self, block_number: BlockNumber, ) -> ProviderResult<Vec<AccountBeforeTx>>

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

impl<TX: DbTx + 'static> DBProvider for DatabaseProvider<TX>

type Tx = TX

Underlying database transaction held by the provider.

fn tx_ref(&self) -> &Self::Tx

Returns a reference to the underlying transaction.

fn tx_mut(&mut self) -> &mut Self::Tx

Returns a mutable reference to the underlying transaction.

fn into_tx(self) -> Self::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

impl<TX: Debug> Debug for DatabaseProvider<TX>

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

Formats the value using the given formatter.

impl<TX: DbTx> EvmEnvProvider for DatabaseProvider<TX>

fn fill_env_at<EvmConfig>( &self, cfg: &mut CfgEnvWithHandlerCfg, block_env: &mut BlockEnv, at: BlockHashOrNumber, evm_config: EvmConfig, ) -> ProviderResult<()>

where EvmConfig: ConfigureEvmEnv,

Fills the [CfgEnvWithHandlerCfg] and [BlockEnv] fields with values specific to the given [BlockHashOrNumber].

fn fill_env_with_header<EvmConfig>( &self, cfg: &mut CfgEnvWithHandlerCfg, block_env: &mut BlockEnv, header: &Header, evm_config: EvmConfig, ) -> ProviderResult<()>

where EvmConfig: ConfigureEvmEnv,

Fills the [CfgEnvWithHandlerCfg] and [BlockEnv] fields with values specific to the given [Header].

fn fill_cfg_env_at<EvmConfig>( &self, cfg: &mut CfgEnvWithHandlerCfg, at: BlockHashOrNumber, evm_config: EvmConfig, ) -> ProviderResult<()>

where EvmConfig: ConfigureEvmEnv,

Fills the [CfgEnvWithHandlerCfg] fields with values specific to the given [BlockHashOrNumber].

fn fill_cfg_env_with_header<EvmConfig>( &self, cfg: &mut CfgEnvWithHandlerCfg, header: &Header, evm_config: EvmConfig, ) -> ProviderResult<()>

where EvmConfig: ConfigureEvmEnv,

Fills the [CfgEnvWithHandlerCfg] fields with values specific to the given [Header].

fn env_with_header<EvmConfig>( &self, header: &Header, evm_config: EvmConfig, ) -> Result<(CfgEnvWithHandlerCfg, BlockEnv), ProviderError>

where EvmConfig: ConfigureEvmEnv,

Fills the default [CfgEnvWithHandlerCfg] and [BlockEnv] fields with values specific to the given [Header].

impl<TX: DbTx> FinalizedBlockReader for DatabaseProvider<TX>

fn last_finalized_block_number(&self) -> ProviderResult<Option<BlockNumber>>

Returns the last finalized block number.

impl<TX: DbTxMut> FinalizedBlockWriter for DatabaseProvider<TX>

fn save_finalized_block_number( &self, block_number: BlockNumber, ) -> ProviderResult<()>

Saves the given finalized block number in the DB.

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

fn from(provider: DatabaseProviderRW<DB>) -> Self

Converts to this type from the input type.

impl<TX: DbTxMut + DbTx> HashingWriter for DatabaseProvider<TX>

fn unwind_account_hashing( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<BTreeMap<B256, Option<Account>>>

Unwind and clear account hashing.

fn insert_account_for_hashing( &self, accounts: impl IntoIterator<Item = (Address, Option<Account>)>, ) -> ProviderResult<BTreeMap<B256, Option<Account>>>

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

fn unwind_storage_hashing( &self, range: Range<BlockNumberAddress>, ) -> ProviderResult<HashMap<B256, BTreeSet<B256>>>

Unwind and clear storage hashing

fn insert_storage_for_hashing( &self, storages: impl IntoIterator<Item = (Address, impl IntoIterator<Item = StorageEntry>)>, ) -> ProviderResult<HashMap<B256, BTreeSet<B256>>>

Iterates over storages and inserts them to hashing table.

fn insert_hashes( &self, range: RangeInclusive<BlockNumber>, end_block_hash: B256, expected_state_root: B256, ) -> ProviderResult<()>

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

impl<TX: DbTx> HeaderProvider for DatabaseProvider<TX>

fn header(&self, block_hash: &BlockHash) -> ProviderResult<Option<Header>>

Get header by block hash

fn header_by_number(&self, num: BlockNumber) -> ProviderResult<Option<Header>>

Get header by block number

fn header_td(&self, block_hash: &BlockHash) -> ProviderResult<Option<U256>>

Get total difficulty by block hash.

fn header_td_by_number( &self, number: BlockNumber, ) -> ProviderResult<Option<U256>>

Get total difficulty by block number.

fn headers_range( &self, range: impl RangeBounds<BlockNumber>, ) -> ProviderResult<Vec<Header>>

Get headers in range of block numbers

fn sealed_header( &self, number: BlockNumber, ) -> ProviderResult<Option<SealedHeader>>

Get a single sealed header by block number.

fn sealed_headers_while( &self, range: impl RangeBounds<BlockNumber>, predicate: impl FnMut(&SealedHeader) -> bool, ) -> ProviderResult<Vec<SealedHeader>>

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 header_by_hash_or_number( &self, hash_or_num: HashOrNumber, ) -> Result<Option<Header>, ProviderError>

Get header by block number or hash

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

Get headers in range of block numbers.

impl<TX: DbTx> HeaderSyncGapProvider for DatabaseProvider<TX>

fn sync_gap( &self, tip: Receiver<B256>, highest_uninterrupted_block: BlockNumber, ) -> ProviderResult<HeaderSyncGap>

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: DbTxMut + DbTx> HistoryWriter for DatabaseProvider<TX>

fn unwind_account_history_indices( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<usize>

Unwind and clear account history indices.

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

Insert account change index to database. Used inside AccountHistoryIndex stage

fn unwind_storage_history_indices( &self, range: Range<BlockNumberAddress>, ) -> ProviderResult<usize>

Unwind and clear storage history indices.

fn insert_storage_history_index( &self, storage_transitions: impl IntoIterator<Item = ((Address, B256), impl IntoIterator<Item = u64>)>, ) -> ProviderResult<()>

Insert storage change index to database. Used inside StorageHistoryIndex stage

fn update_history_indices( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<()>

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

impl<TX: DbTx> PruneCheckpointReader for DatabaseProvider<TX>

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

Fetch the prune checkpoint for the given segment.

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

Fetch all the prune checkpoints.

impl<TX: DbTxMut> PruneCheckpointWriter for DatabaseProvider<TX>

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

Save prune checkpoint.

impl<TX: DbTx> ReceiptProvider for DatabaseProvider<TX>

fn receipt(&self, id: TxNumber) -> ProviderResult<Option<Receipt>>

Get receipt by transaction number

fn receipt_by_hash(&self, hash: TxHash) -> ProviderResult<Option<Receipt>>

Get receipt by transaction hash.

fn receipts_by_block( &self, block: BlockHashOrNumber, ) -> ProviderResult<Option<Vec<Receipt>>>

Get receipts by block num or hash.

fn receipts_by_tx_range( &self, range: impl RangeBounds<TxNumber>, ) -> ProviderResult<Vec<Receipt>>

Get receipts by tx range.

impl<TX: DbTx> RequestsProvider for DatabaseProvider<TX>

fn requests_by_block( &self, id: BlockHashOrNumber, timestamp: u64, ) -> ProviderResult<Option<Requests>>

Get withdrawals by block id.

impl<TX: DbTx> StageCheckpointReader for DatabaseProvider<TX>

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

Get stage checkpoint progress.

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

Fetch the checkpoint for the given stage.

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

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

impl<TX: DbTxMut> StageCheckpointWriter for DatabaseProvider<TX>

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

Save stage checkpoint.

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

Save stage checkpoint progress.

fn update_pipeline_stages( &self, block_number: BlockNumber, drop_stage_checkpoint: bool, ) -> ProviderResult<()>

Update all pipeline sync stage progress.

impl<TX: DbTxMut + DbTx> StateChangeWriter for DatabaseProvider<TX>

fn write_state_reverts( &self, reverts: PlainStateReverts, first_block: BlockNumber, ) -> ProviderResult<()>

Write state reverts to the database.

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

Write state changes to the database.

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

Writes the hashed state changes to the database

impl<TX: DbTx> StateReader for DatabaseProvider<TX>

fn get_state( &self, block: BlockNumber, ) -> ProviderResult<Option<ExecutionOutcome>>

Get the ExecutionOutcome for the given block

impl<TX: DbTx> StatsReader for DatabaseProvider<TX>

fn count_entries<T: Table>(&self) -> ProviderResult<usize>

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: DbTx> StorageReader for DatabaseProvider<TX>

fn plain_state_storages( &self, addresses_with_keys: impl IntoIterator<Item = (Address, impl IntoIterator<Item = B256>)>, ) -> ProviderResult<Vec<(Address, Vec<StorageEntry>)>>

Get plainstate storages for addresses and storage keys.

fn changed_storages_with_range( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<BTreeMap<Address, BTreeSet<B256>>>

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

fn changed_storages_and_blocks_with_range( &self, range: RangeInclusive<BlockNumber>, ) -> ProviderResult<BTreeMap<(Address, B256), Vec<u64>>>

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

impl<TX: DbTxMut + DbTx> StorageTrieWriter for DatabaseProvider<TX>

fn write_storage_trie_updates( &self, storage_tries: &HashMap<B256, StorageTrieUpdates>, ) -> ProviderResult<usize>

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: B256, updates: &StorageTrieUpdates, ) -> ProviderResult<usize>

Writes storage trie updates for the given hashed address.

impl<TX: DbTx> TransactionsProvider for DatabaseProvider<TX>

fn transaction_id(&self, tx_hash: TxHash) -> ProviderResult<Option<TxNumber>>

Get internal transaction identifier by transaction hash.

fn transaction_by_id( &self, id: TxNumber, ) -> ProviderResult<Option<TransactionSigned>>

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

fn transaction_by_id_no_hash( &self, id: TxNumber, ) -> ProviderResult<Option<TransactionSignedNoHash>>

Get transaction by id without computing the hash.

fn transaction_by_hash( &self, hash: TxHash, ) -> ProviderResult<Option<TransactionSigned>>

Get transaction by transaction hash.

fn transaction_by_hash_with_meta( &self, tx_hash: TxHash, ) -> ProviderResult<Option<(TransactionSigned, TransactionMeta)>>

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

fn transaction_block(&self, id: TxNumber) -> ProviderResult<Option<BlockNumber>>

Get transaction block number

fn transactions_by_block( &self, id: BlockHashOrNumber, ) -> ProviderResult<Option<Vec<TransactionSigned>>>

Get transactions by block id.

fn transactions_by_block_range( &self, range: impl RangeBounds<BlockNumber>, ) -> ProviderResult<Vec<Vec<TransactionSigned>>>

Get transactions by block range.

fn transactions_by_tx_range( &self, range: impl RangeBounds<TxNumber>, ) -> ProviderResult<Vec<TransactionSignedNoHash>>

Get transactions by tx range.

fn senders_by_tx_range( &self, range: impl RangeBounds<TxNumber>, ) -> ProviderResult<Vec<Address>>

Get Senders from a tx range.

fn transaction_sender(&self, id: TxNumber) -> ProviderResult<Option<Address>>

Get transaction sender.

impl<TX: DbTx> TransactionsProviderExt for DatabaseProvider<TX>

fn transaction_hashes_by_range( &self, tx_range: Range<TxNumber>, ) -> ProviderResult<Vec<(TxHash, TxNumber)>>

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: DbTxMut + DbTx> TrieWriter for DatabaseProvider<TX>

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

Writes trie updates. Returns the number of entries modified.

impl<TX: DbTx + 'static> TryIntoHistoricalStateProvider for DatabaseProvider<TX>

fn try_into_history_at_block( self, block_number: BlockNumber, ) -> ProviderResult<StateProviderBox>

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

impl<TX: DbTx> WithdrawalsProvider for DatabaseProvider<TX>

fn withdrawals_by_block( &self, id: BlockHashOrNumber, timestamp: u64, ) -> ProviderResult<Option<Withdrawals>>

Get withdrawals by block id.

fn latest_withdrawal(&self) -> ProviderResult<Option<Withdrawal>>

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.