Struct UnifiedStorageWriter

pub struct UnifiedStorageWriter<'a, ProviderDB, ProviderSF> { /* private fields */ }

UnifiedStorageWriter is responsible for managing the writing to storage with both database and static file providers.

Implementations

impl<'a, ProviderDB, ProviderSF> UnifiedStorageWriter<'a, ProviderDB, ProviderSF>

pub const fn new( database: &'a ProviderDB, static_file: Option<ProviderSF>, ) -> Self

Creates a new instance of UnifiedStorageWriter.

Parameters

• database: An optional reference to a database provider.
• static_file: An optional mutable reference to a static file instance.

pub fn from<P>(database: &'a P, static_file: ProviderSF) -> Self

where P: AsRef<ProviderDB>,

Creates a new instance of UnifiedStorageWriter from a database provider and a static file instance.

pub fn from_database<P>(database: &'a P) -> Self

where P: AsRef<ProviderDB>,

Creates a new instance of UnifiedStorageWriter from a database provider.

impl UnifiedStorageWriter<'_, (), ()>

pub fn commit<P>( database: impl Into<P> + AsRef<P>, static_file: StaticFileProvider, ) -> ProviderResult<()>

where P: DBProvider<Tx: DbTxMut>,

Commits both storage types in the right order.

For non-unwinding operations it makes more sense to commit the static files first, since if it is interrupted before the database commit, we can just truncate the static files according to the checkpoints on the next start-up.

NOTE: If unwinding data from storage, use commit_unwind instead!

pub fn commit_unwind<P>( database: impl Into<P> + AsRef<P>, static_file: StaticFileProvider, ) -> ProviderResult<()>

where P: DBProvider<Tx: DbTxMut>,

Commits both storage types in the right order for an unwind operation.

For unwinding it makes more sense to commit the database first, since if it is interrupted before the static files commit, we can just truncate the static files according to the checkpoints on the next start-up.

NOTE: Should only be used after unwinding data from storage!

impl<ProviderDB> UnifiedStorageWriter<'_, ProviderDB, &StaticFileProvider>

where ProviderDB: DBProvider<Tx: DbTx + DbTxMut> + BlockWriter + TransactionsProviderExt + StateChangeWriter + TrieWriter + HistoryWriter + StageCheckpointWriter + BlockExecutionWriter + AsRef<ProviderDB>,

pub fn save_blocks(&self, blocks: &[ExecutedBlock]) -> ProviderResult<()>

Writes executed blocks and receipts to storage.

pub fn remove_blocks_above(&self, block_number: u64) -> ProviderResult<()>

Removes all block, transaction and receipt data above the given block number from the database and static files. This is exclusive, i.e., it only removes blocks above block_number, and does not remove block_number.

impl<ProviderDB> UnifiedStorageWriter<'_, ProviderDB, StaticFileProviderRWRefMut<'_>>

where ProviderDB: DBProvider<Tx: DbTx> + HeaderProvider,

pub fn append_headers_from_blocks<H, I>( &mut self, initial_block_number: BlockNumber, headers: impl Iterator<Item = I>, ) -> ProviderResult<U256>

where I: Borrow<(H, B256)>, H: Borrow<Header>,

Appends headers to static files, using the HeaderTerminalDifficulties table to determine the total difficulty of the parent block during header insertion.

NOTE: The static file writer used to construct this UnifiedStorageWriter MUST be a writer for the Headers segment.

pub fn append_transactions_from_blocks<T>( &mut self, initial_block_number: BlockNumber, transactions: impl Iterator<Item = T>, ) -> ProviderResult<()>

where T: Borrow<Vec<TransactionSignedNoHash>>,

Appends transactions to static files, using the BlockBodyIndices table to determine the transaction number when appending to static files.

NOTE: The static file writer used to construct this UnifiedStorageWriter MUST be a writer for the Transactions segment.

impl<ProviderDB> UnifiedStorageWriter<'_, ProviderDB, StaticFileProviderRWRefMut<'_>>

where ProviderDB: DBProvider<Tx: DbTxMut + DbTx> + HeaderProvider,

pub fn append_receipts_from_blocks( &mut self, initial_block_number: BlockNumber, blocks: impl Iterator<Item = Vec<Option<Receipt>>>, ) -> ProviderResult<()>

Appends receipts block by block.

ATTENTION: If called from UnifiedStorageWriter without a static file producer, it will always write them to database. Otherwise, it will look into the pruning configuration to decide.

NOTE: The static file writer used to construct this UnifiedStorageWriter MUST be a writer for the Receipts segment.

Parameters

• initial_block_number: The starting block number.
• blocks: An iterator over blocks, each block having a vector of optional receipts. If receipt is None, it has been pruned.

Trait Implementations

impl<'a, ProviderDB: Debug, ProviderSF: Debug> Debug for UnifiedStorageWriter<'a, ProviderDB, ProviderSF>

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

Formats the value using the given formatter.

impl<ProviderDB> StateWriter for UnifiedStorageWriter<'_, ProviderDB, StaticFileProviderRWRefMut<'_>>

where ProviderDB: DBProvider<Tx: DbTxMut + DbTx> + StateChangeWriter + HeaderProvider,

fn write_to_storage( &mut self, execution_outcome: ExecutionOutcome, is_value_known: OriginalValuesKnown, ) -> ProviderResult<()>

Write the data 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.

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.