reth_provider/providers/state/
historical.rs

1use crate::{
2    providers::state::macros::delegate_provider_impls, AccountReader, BlockHashReader,
3    ChangeSetReader, HashedPostStateProvider, ProviderError, StateProvider, StateRootProvider,
4};
5use alloy_eips::merge::EPOCH_SLOTS;
6use alloy_primitives::{Address, BlockNumber, Bytes, StorageKey, StorageValue, B256};
7use reth_db_api::{
8    cursor::{DbCursorRO, DbDupCursorRO},
9    models::{storage_sharded_key::StorageShardedKey, ShardedKey},
10    table::Table,
11    tables,
12    transaction::DbTx,
13    BlockNumberList,
14};
15use reth_primitives_traits::{Account, Bytecode};
16use reth_storage_api::{
17    BlockNumReader, BytecodeReader, DBProvider, StateProofProvider, StorageRootProvider,
18};
19use reth_storage_errors::provider::ProviderResult;
20use reth_trie::{
21    proof::{Proof, StorageProof},
22    updates::TrieUpdates,
23    witness::TrieWitness,
24    AccountProof, HashedPostState, HashedStorage, KeccakKeyHasher, MultiProof, MultiProofTargets,
25    StateRoot, StorageMultiProof, StorageRoot, TrieInput,
26};
27use reth_trie_db::{
28    DatabaseHashedPostState, DatabaseHashedStorage, DatabaseProof, DatabaseStateRoot,
29    DatabaseStorageProof, DatabaseStorageRoot, DatabaseTrieWitness,
30};
31
32use std::fmt::Debug;
33
34/// State provider for a given block number which takes a tx reference.
35///
36/// Historical state provider accesses the state at the start of the provided block number.
37/// It means that all changes made in the provided block number are not included.
38///
39/// Historical state provider reads the following tables:
40/// - [`tables::AccountsHistory`]
41/// - [`tables::Bytecodes`]
42/// - [`tables::StoragesHistory`]
43/// - [`tables::AccountChangeSets`]
44/// - [`tables::StorageChangeSets`]
45#[derive(Debug)]
46pub struct HistoricalStateProviderRef<'b, Provider> {
47    /// Database provider
48    provider: &'b Provider,
49    /// Block number is main index for the history state of accounts and storages.
50    block_number: BlockNumber,
51    /// Lowest blocks at which different parts of the state are available.
52    lowest_available_blocks: LowestAvailableBlocks,
53}
54
55#[derive(Debug, Eq, PartialEq)]
56pub enum HistoryInfo {
57    NotYetWritten,
58    InChangeset(u64),
59    InPlainState,
60    MaybeInPlainState,
61}
62
63impl<'b, Provider: DBProvider + BlockNumReader> HistoricalStateProviderRef<'b, Provider> {
64    /// Create new `StateProvider` for historical block number
65    pub fn new(provider: &'b Provider, block_number: BlockNumber) -> Self {
66        Self { provider, block_number, lowest_available_blocks: Default::default() }
67    }
68
69    /// Create new `StateProvider` for historical block number and lowest block numbers at which
70    /// account & storage histories are available.
71    pub const fn new_with_lowest_available_blocks(
72        provider: &'b Provider,
73        block_number: BlockNumber,
74        lowest_available_blocks: LowestAvailableBlocks,
75    ) -> Self {
76        Self { provider, block_number, lowest_available_blocks }
77    }
78
79    /// Lookup an account in the `AccountsHistory` table
80    pub fn account_history_lookup(&self, address: Address) -> ProviderResult<HistoryInfo> {
81        if !self.lowest_available_blocks.is_account_history_available(self.block_number) {
82            return Err(ProviderError::StateAtBlockPruned(self.block_number))
83        }
84
85        // history key to search IntegerList of block number changesets.
86        let history_key = ShardedKey::new(address, self.block_number);
87        self.history_info::<tables::AccountsHistory, _>(
88            history_key,
89            |key| key.key == address,
90            self.lowest_available_blocks.account_history_block_number,
91        )
92    }
93
94    /// Lookup a storage key in the `StoragesHistory` table
95    pub fn storage_history_lookup(
96        &self,
97        address: Address,
98        storage_key: StorageKey,
99    ) -> ProviderResult<HistoryInfo> {
100        if !self.lowest_available_blocks.is_storage_history_available(self.block_number) {
101            return Err(ProviderError::StateAtBlockPruned(self.block_number))
102        }
103
104        // history key to search IntegerList of block number changesets.
105        let history_key = StorageShardedKey::new(address, storage_key, self.block_number);
106        self.history_info::<tables::StoragesHistory, _>(
107            history_key,
108            |key| key.address == address && key.sharded_key.key == storage_key,
109            self.lowest_available_blocks.storage_history_block_number,
110        )
111    }
112
113    /// Checks and returns `true` if distance to historical block exceeds the provided limit.
114    fn check_distance_against_limit(&self, limit: u64) -> ProviderResult<bool> {
115        let tip = self.provider.last_block_number()?;
116
117        Ok(tip.saturating_sub(self.block_number) > limit)
118    }
119
120    /// Retrieve revert hashed state for this history provider.
121    fn revert_state(&self) -> ProviderResult<HashedPostState> {
122        if !self.lowest_available_blocks.is_account_history_available(self.block_number) ||
123            !self.lowest_available_blocks.is_storage_history_available(self.block_number)
124        {
125            return Err(ProviderError::StateAtBlockPruned(self.block_number))
126        }
127
128        if self.check_distance_against_limit(EPOCH_SLOTS)? {
129            tracing::warn!(
130                target: "provider::historical_sp",
131                target = self.block_number,
132                "Attempt to calculate state root for an old block might result in OOM"
133            );
134        }
135
136        Ok(HashedPostState::from_reverts::<KeccakKeyHasher>(self.tx(), self.block_number..)?)
137    }
138
139    /// Retrieve revert hashed storage for this history provider and target address.
140    fn revert_storage(&self, address: Address) -> ProviderResult<HashedStorage> {
141        if !self.lowest_available_blocks.is_storage_history_available(self.block_number) {
142            return Err(ProviderError::StateAtBlockPruned(self.block_number))
143        }
144
145        if self.check_distance_against_limit(EPOCH_SLOTS * 10)? {
146            tracing::warn!(
147                target: "provider::historical_sp",
148                target = self.block_number,
149                "Attempt to calculate storage root for an old block might result in OOM"
150            );
151        }
152
153        Ok(HashedStorage::from_reverts(self.tx(), address, self.block_number)?)
154    }
155
156    fn history_info<T, K>(
157        &self,
158        key: K,
159        key_filter: impl Fn(&K) -> bool,
160        lowest_available_block_number: Option<BlockNumber>,
161    ) -> ProviderResult<HistoryInfo>
162    where
163        T: Table<Key = K, Value = BlockNumberList>,
164    {
165        let mut cursor = self.tx().cursor_read::<T>()?;
166
167        // Lookup the history chunk in the history index. If they key does not appear in the
168        // index, the first chunk for the next key will be returned so we filter out chunks that
169        // have a different key.
170        if let Some(chunk) = cursor.seek(key)?.filter(|(key, _)| key_filter(key)).map(|x| x.1 .0) {
171            // Get the rank of the first entry before or equal to our block.
172            let mut rank = chunk.rank(self.block_number);
173
174            // Adjust the rank, so that we have the rank of the first entry strictly before our
175            // block (not equal to it).
176            if rank.checked_sub(1).and_then(|rank| chunk.select(rank)) == Some(self.block_number) {
177                rank -= 1
178            };
179
180            let block_number = chunk.select(rank);
181
182            // If our block is before the first entry in the index chunk and this first entry
183            // doesn't equal to our block, it might be before the first write ever. To check, we
184            // look at the previous entry and check if the key is the same.
185            // This check is worth it, the `cursor.prev()` check is rarely triggered (the if will
186            // short-circuit) and when it passes we save a full seek into the changeset/plain state
187            // table.
188            if rank == 0 &&
189                block_number != Some(self.block_number) &&
190                !cursor.prev()?.is_some_and(|(key, _)| key_filter(&key))
191            {
192                if let (Some(_), Some(block_number)) = (lowest_available_block_number, block_number)
193                {
194                    // The key may have been written, but due to pruning we may not have changesets
195                    // and history, so we need to make a changeset lookup.
196                    Ok(HistoryInfo::InChangeset(block_number))
197                } else {
198                    // The key is written to, but only after our block.
199                    Ok(HistoryInfo::NotYetWritten)
200                }
201            } else if let Some(block_number) = block_number {
202                // The chunk contains an entry for a write after our block, return it.
203                Ok(HistoryInfo::InChangeset(block_number))
204            } else {
205                // The chunk does not contain an entry for a write after our block. This can only
206                // happen if this is the last chunk and so we need to look in the plain state.
207                Ok(HistoryInfo::InPlainState)
208            }
209        } else if lowest_available_block_number.is_some() {
210            // The key may have been written, but due to pruning we may not have changesets and
211            // history, so we need to make a plain state lookup.
212            Ok(HistoryInfo::MaybeInPlainState)
213        } else {
214            // The key has not been written to at all.
215            Ok(HistoryInfo::NotYetWritten)
216        }
217    }
218
219    /// Set the lowest block number at which the account history is available.
220    pub const fn with_lowest_available_account_history_block_number(
221        mut self,
222        block_number: BlockNumber,
223    ) -> Self {
224        self.lowest_available_blocks.account_history_block_number = Some(block_number);
225        self
226    }
227
228    /// Set the lowest block number at which the storage history is available.
229    pub const fn with_lowest_available_storage_history_block_number(
230        mut self,
231        block_number: BlockNumber,
232    ) -> Self {
233        self.lowest_available_blocks.storage_history_block_number = Some(block_number);
234        self
235    }
236}
237
238impl<Provider: DBProvider + BlockNumReader> HistoricalStateProviderRef<'_, Provider> {
239    fn tx(&self) -> &Provider::Tx {
240        self.provider.tx_ref()
241    }
242}
243
244impl<Provider: DBProvider + BlockNumReader + ChangeSetReader> AccountReader
245    for HistoricalStateProviderRef<'_, Provider>
246{
247    /// Get basic account information.
248    fn basic_account(&self, address: &Address) -> ProviderResult<Option<Account>> {
249        match self.account_history_lookup(*address)? {
250            HistoryInfo::NotYetWritten => Ok(None),
251            HistoryInfo::InChangeset(changeset_block_number) => {
252                // Use ChangeSetReader trait method to get the account from changesets
253                self.provider
254                    .get_account_before_block(changeset_block_number, *address)?
255                    .ok_or(ProviderError::AccountChangesetNotFound {
256                        block_number: changeset_block_number,
257                        address: *address,
258                    })
259                    .map(|account_before| account_before.info)
260            }
261            HistoryInfo::InPlainState | HistoryInfo::MaybeInPlainState => {
262                Ok(self.tx().get_by_encoded_key::<tables::PlainAccountState>(address)?)
263            }
264        }
265    }
266}
267
268impl<Provider: DBProvider + BlockNumReader + BlockHashReader> BlockHashReader
269    for HistoricalStateProviderRef<'_, Provider>
270{
271    /// Get block hash by number.
272    fn block_hash(&self, number: u64) -> ProviderResult<Option<B256>> {
273        self.provider.block_hash(number)
274    }
275
276    fn canonical_hashes_range(
277        &self,
278        start: BlockNumber,
279        end: BlockNumber,
280    ) -> ProviderResult<Vec<B256>> {
281        self.provider.canonical_hashes_range(start, end)
282    }
283}
284
285impl<Provider: DBProvider + BlockNumReader> StateRootProvider
286    for HistoricalStateProviderRef<'_, Provider>
287{
288    fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
289        let mut revert_state = self.revert_state()?;
290        revert_state.extend(hashed_state);
291        StateRoot::overlay_root(self.tx(), revert_state)
292            .map_err(|err| ProviderError::Database(err.into()))
293    }
294
295    fn state_root_from_nodes(&self, mut input: TrieInput) -> ProviderResult<B256> {
296        input.prepend(self.revert_state()?);
297        StateRoot::overlay_root_from_nodes(self.tx(), input)
298            .map_err(|err| ProviderError::Database(err.into()))
299    }
300
301    fn state_root_with_updates(
302        &self,
303        hashed_state: HashedPostState,
304    ) -> ProviderResult<(B256, TrieUpdates)> {
305        let mut revert_state = self.revert_state()?;
306        revert_state.extend(hashed_state);
307        StateRoot::overlay_root_with_updates(self.tx(), revert_state)
308            .map_err(|err| ProviderError::Database(err.into()))
309    }
310
311    fn state_root_from_nodes_with_updates(
312        &self,
313        mut input: TrieInput,
314    ) -> ProviderResult<(B256, TrieUpdates)> {
315        input.prepend(self.revert_state()?);
316        StateRoot::overlay_root_from_nodes_with_updates(self.tx(), input)
317            .map_err(|err| ProviderError::Database(err.into()))
318    }
319}
320
321impl<Provider: DBProvider + BlockNumReader> StorageRootProvider
322    for HistoricalStateProviderRef<'_, Provider>
323{
324    fn storage_root(
325        &self,
326        address: Address,
327        hashed_storage: HashedStorage,
328    ) -> ProviderResult<B256> {
329        let mut revert_storage = self.revert_storage(address)?;
330        revert_storage.extend(&hashed_storage);
331        StorageRoot::overlay_root(self.tx(), address, revert_storage)
332            .map_err(|err| ProviderError::Database(err.into()))
333    }
334
335    fn storage_proof(
336        &self,
337        address: Address,
338        slot: B256,
339        hashed_storage: HashedStorage,
340    ) -> ProviderResult<reth_trie::StorageProof> {
341        let mut revert_storage = self.revert_storage(address)?;
342        revert_storage.extend(&hashed_storage);
343        StorageProof::overlay_storage_proof(self.tx(), address, slot, revert_storage)
344            .map_err(ProviderError::from)
345    }
346
347    fn storage_multiproof(
348        &self,
349        address: Address,
350        slots: &[B256],
351        hashed_storage: HashedStorage,
352    ) -> ProviderResult<StorageMultiProof> {
353        let mut revert_storage = self.revert_storage(address)?;
354        revert_storage.extend(&hashed_storage);
355        StorageProof::overlay_storage_multiproof(self.tx(), address, slots, revert_storage)
356            .map_err(ProviderError::from)
357    }
358}
359
360impl<Provider: DBProvider + BlockNumReader> StateProofProvider
361    for HistoricalStateProviderRef<'_, Provider>
362{
363    /// Get account and storage proofs.
364    fn proof(
365        &self,
366        mut input: TrieInput,
367        address: Address,
368        slots: &[B256],
369    ) -> ProviderResult<AccountProof> {
370        input.prepend(self.revert_state()?);
371        Proof::overlay_account_proof(self.tx(), input, address, slots).map_err(ProviderError::from)
372    }
373
374    fn multiproof(
375        &self,
376        mut input: TrieInput,
377        targets: MultiProofTargets,
378    ) -> ProviderResult<MultiProof> {
379        input.prepend(self.revert_state()?);
380        Proof::overlay_multiproof(self.tx(), input, targets).map_err(ProviderError::from)
381    }
382
383    fn witness(&self, mut input: TrieInput, target: HashedPostState) -> ProviderResult<Vec<Bytes>> {
384        input.prepend(self.revert_state()?);
385        TrieWitness::overlay_witness(self.tx(), input, target)
386            .map_err(ProviderError::from)
387            .map(|hm| hm.into_values().collect())
388    }
389}
390
391impl<Provider: Sync> HashedPostStateProvider for HistoricalStateProviderRef<'_, Provider> {
392    fn hashed_post_state(&self, bundle_state: &revm_database::BundleState) -> HashedPostState {
393        HashedPostState::from_bundle_state::<KeccakKeyHasher>(bundle_state.state())
394    }
395}
396
397impl<Provider: DBProvider + BlockNumReader + BlockHashReader + ChangeSetReader> StateProvider
398    for HistoricalStateProviderRef<'_, Provider>
399{
400    /// Get storage.
401    fn storage(
402        &self,
403        address: Address,
404        storage_key: StorageKey,
405    ) -> ProviderResult<Option<StorageValue>> {
406        match self.storage_history_lookup(address, storage_key)? {
407            HistoryInfo::NotYetWritten => Ok(None),
408            HistoryInfo::InChangeset(changeset_block_number) => Ok(Some(
409                self.tx()
410                    .cursor_dup_read::<tables::StorageChangeSets>()?
411                    .seek_by_key_subkey((changeset_block_number, address).into(), storage_key)?
412                    .filter(|entry| entry.key == storage_key)
413                    .ok_or_else(|| ProviderError::StorageChangesetNotFound {
414                        block_number: changeset_block_number,
415                        address,
416                        storage_key: Box::new(storage_key),
417                    })?
418                    .value,
419            )),
420            HistoryInfo::InPlainState | HistoryInfo::MaybeInPlainState => Ok(self
421                .tx()
422                .cursor_dup_read::<tables::PlainStorageState>()?
423                .seek_by_key_subkey(address, storage_key)?
424                .filter(|entry| entry.key == storage_key)
425                .map(|entry| entry.value)
426                .or(Some(StorageValue::ZERO))),
427        }
428    }
429}
430
431impl<Provider: DBProvider + BlockNumReader> BytecodeReader
432    for HistoricalStateProviderRef<'_, Provider>
433{
434    /// Get account code by its hash
435    fn bytecode_by_hash(&self, code_hash: &B256) -> ProviderResult<Option<Bytecode>> {
436        self.tx().get_by_encoded_key::<tables::Bytecodes>(code_hash).map_err(Into::into)
437    }
438}
439
440/// State provider for a given block number.
441/// For more detailed description, see [`HistoricalStateProviderRef`].
442#[derive(Debug)]
443pub struct HistoricalStateProvider<Provider> {
444    /// Database provider.
445    provider: Provider,
446    /// State at the block number is the main indexer of the state.
447    block_number: BlockNumber,
448    /// Lowest blocks at which different parts of the state are available.
449    lowest_available_blocks: LowestAvailableBlocks,
450}
451
452impl<Provider: DBProvider + BlockNumReader> HistoricalStateProvider<Provider> {
453    /// Create new `StateProvider` for historical block number
454    pub fn new(provider: Provider, block_number: BlockNumber) -> Self {
455        Self { provider, block_number, lowest_available_blocks: Default::default() }
456    }
457
458    /// Set the lowest block number at which the account history is available.
459    pub const fn with_lowest_available_account_history_block_number(
460        mut self,
461        block_number: BlockNumber,
462    ) -> Self {
463        self.lowest_available_blocks.account_history_block_number = Some(block_number);
464        self
465    }
466
467    /// Set the lowest block number at which the storage history is available.
468    pub const fn with_lowest_available_storage_history_block_number(
469        mut self,
470        block_number: BlockNumber,
471    ) -> Self {
472        self.lowest_available_blocks.storage_history_block_number = Some(block_number);
473        self
474    }
475
476    /// Returns a new provider that takes the `TX` as reference
477    #[inline(always)]
478    const fn as_ref(&self) -> HistoricalStateProviderRef<'_, Provider> {
479        HistoricalStateProviderRef::new_with_lowest_available_blocks(
480            &self.provider,
481            self.block_number,
482            self.lowest_available_blocks,
483        )
484    }
485}
486
487// Delegates all provider impls to [HistoricalStateProviderRef]
488delegate_provider_impls!(HistoricalStateProvider<Provider> where [Provider: DBProvider + BlockNumReader + BlockHashReader + ChangeSetReader]);
489
490/// Lowest blocks at which different parts of the state are available.
491/// They may be [Some] if pruning is enabled.
492#[derive(Clone, Copy, Debug, Default)]
493pub struct LowestAvailableBlocks {
494    /// Lowest block number at which the account history is available. It may not be available if
495    /// [`reth_prune_types::PruneSegment::AccountHistory`] was pruned.
496    /// [`Option::None`] means all history is available.
497    pub account_history_block_number: Option<BlockNumber>,
498    /// Lowest block number at which the storage history is available. It may not be available if
499    /// [`reth_prune_types::PruneSegment::StorageHistory`] was pruned.
500    /// [`Option::None`] means all history is available.
501    pub storage_history_block_number: Option<BlockNumber>,
502}
503
504impl LowestAvailableBlocks {
505    /// Check if account history is available at the provided block number, i.e. lowest available
506    /// block number for account history is less than or equal to the provided block number.
507    pub fn is_account_history_available(&self, at: BlockNumber) -> bool {
508        self.account_history_block_number.map(|block_number| block_number <= at).unwrap_or(true)
509    }
510
511    /// Check if storage history is available at the provided block number, i.e. lowest available
512    /// block number for storage history is less than or equal to the provided block number.
513    pub fn is_storage_history_available(&self, at: BlockNumber) -> bool {
514        self.storage_history_block_number.map(|block_number| block_number <= at).unwrap_or(true)
515    }
516}
517
518#[cfg(test)]
519mod tests {
520    use crate::{
521        providers::state::historical::{HistoryInfo, LowestAvailableBlocks},
522        test_utils::create_test_provider_factory,
523        AccountReader, HistoricalStateProvider, HistoricalStateProviderRef, StateProvider,
524    };
525    use alloy_primitives::{address, b256, Address, B256, U256};
526    use reth_db_api::{
527        models::{storage_sharded_key::StorageShardedKey, AccountBeforeTx, ShardedKey},
528        tables,
529        transaction::{DbTx, DbTxMut},
530        BlockNumberList,
531    };
532    use reth_primitives_traits::{Account, StorageEntry};
533    use reth_storage_api::{
534        BlockHashReader, BlockNumReader, ChangeSetReader, DBProvider, DatabaseProviderFactory,
535    };
536    use reth_storage_errors::provider::ProviderError;
537
538    const ADDRESS: Address = address!("0x0000000000000000000000000000000000000001");
539    const HIGHER_ADDRESS: Address = address!("0x0000000000000000000000000000000000000005");
540    const STORAGE: B256 =
541        b256!("0x0000000000000000000000000000000000000000000000000000000000000001");
542
543    const fn assert_state_provider<T: StateProvider>() {}
544    #[expect(dead_code)]
545    const fn assert_historical_state_provider<
546        T: DBProvider + BlockNumReader + BlockHashReader + ChangeSetReader,
547    >() {
548        assert_state_provider::<HistoricalStateProvider<T>>();
549    }
550
551    #[test]
552    fn history_provider_get_account() {
553        let factory = create_test_provider_factory();
554        let tx = factory.provider_rw().unwrap().into_tx();
555
556        tx.put::<tables::AccountsHistory>(
557            ShardedKey { key: ADDRESS, highest_block_number: 7 },
558            BlockNumberList::new([1, 3, 7]).unwrap(),
559        )
560        .unwrap();
561        tx.put::<tables::AccountsHistory>(
562            ShardedKey { key: ADDRESS, highest_block_number: u64::MAX },
563            BlockNumberList::new([10, 15]).unwrap(),
564        )
565        .unwrap();
566        tx.put::<tables::AccountsHistory>(
567            ShardedKey { key: HIGHER_ADDRESS, highest_block_number: u64::MAX },
568            BlockNumberList::new([4]).unwrap(),
569        )
570        .unwrap();
571
572        let acc_plain = Account { nonce: 100, balance: U256::ZERO, bytecode_hash: None };
573        let acc_at15 = Account { nonce: 15, balance: U256::ZERO, bytecode_hash: None };
574        let acc_at10 = Account { nonce: 10, balance: U256::ZERO, bytecode_hash: None };
575        let acc_at7 = Account { nonce: 7, balance: U256::ZERO, bytecode_hash: None };
576        let acc_at3 = Account { nonce: 3, balance: U256::ZERO, bytecode_hash: None };
577
578        let higher_acc_plain = Account { nonce: 4, balance: U256::ZERO, bytecode_hash: None };
579
580        // setup
581        tx.put::<tables::AccountChangeSets>(1, AccountBeforeTx { address: ADDRESS, info: None })
582            .unwrap();
583        tx.put::<tables::AccountChangeSets>(
584            3,
585            AccountBeforeTx { address: ADDRESS, info: Some(acc_at3) },
586        )
587        .unwrap();
588        tx.put::<tables::AccountChangeSets>(
589            4,
590            AccountBeforeTx { address: HIGHER_ADDRESS, info: None },
591        )
592        .unwrap();
593        tx.put::<tables::AccountChangeSets>(
594            7,
595            AccountBeforeTx { address: ADDRESS, info: Some(acc_at7) },
596        )
597        .unwrap();
598        tx.put::<tables::AccountChangeSets>(
599            10,
600            AccountBeforeTx { address: ADDRESS, info: Some(acc_at10) },
601        )
602        .unwrap();
603        tx.put::<tables::AccountChangeSets>(
604            15,
605            AccountBeforeTx { address: ADDRESS, info: Some(acc_at15) },
606        )
607        .unwrap();
608
609        // setup plain state
610        tx.put::<tables::PlainAccountState>(ADDRESS, acc_plain).unwrap();
611        tx.put::<tables::PlainAccountState>(HIGHER_ADDRESS, higher_acc_plain).unwrap();
612        tx.commit().unwrap();
613
614        let db = factory.provider().unwrap();
615
616        // run
617        assert!(matches!(
618            HistoricalStateProviderRef::new(&db, 1).basic_account(&ADDRESS),
619            Ok(None)
620        ));
621        assert!(matches!(
622            HistoricalStateProviderRef::new(&db, 2).basic_account(&ADDRESS),
623            Ok(Some(acc)) if acc == acc_at3
624        ));
625        assert!(matches!(
626            HistoricalStateProviderRef::new(&db, 3).basic_account(&ADDRESS),
627            Ok(Some(acc)) if acc == acc_at3
628        ));
629        assert!(matches!(
630            HistoricalStateProviderRef::new(&db, 4).basic_account(&ADDRESS),
631            Ok(Some(acc)) if acc == acc_at7
632        ));
633        assert!(matches!(
634            HistoricalStateProviderRef::new(&db, 7).basic_account(&ADDRESS),
635            Ok(Some(acc)) if acc == acc_at7
636        ));
637        assert!(matches!(
638            HistoricalStateProviderRef::new(&db, 9).basic_account(&ADDRESS),
639            Ok(Some(acc)) if acc == acc_at10
640        ));
641        assert!(matches!(
642            HistoricalStateProviderRef::new(&db, 10).basic_account(&ADDRESS),
643            Ok(Some(acc)) if acc == acc_at10
644        ));
645        assert!(matches!(
646            HistoricalStateProviderRef::new(&db, 11).basic_account(&ADDRESS),
647            Ok(Some(acc)) if acc == acc_at15
648        ));
649        assert!(matches!(
650            HistoricalStateProviderRef::new(&db, 16).basic_account(&ADDRESS),
651            Ok(Some(acc)) if acc == acc_plain
652        ));
653
654        assert!(matches!(
655            HistoricalStateProviderRef::new(&db, 1).basic_account(&HIGHER_ADDRESS),
656            Ok(None)
657        ));
658        assert!(matches!(
659            HistoricalStateProviderRef::new(&db, 1000).basic_account(&HIGHER_ADDRESS),
660            Ok(Some(acc)) if acc == higher_acc_plain
661        ));
662    }
663
664    #[test]
665    fn history_provider_get_storage() {
666        let factory = create_test_provider_factory();
667        let tx = factory.provider_rw().unwrap().into_tx();
668
669        tx.put::<tables::StoragesHistory>(
670            StorageShardedKey {
671                address: ADDRESS,
672                sharded_key: ShardedKey { key: STORAGE, highest_block_number: 7 },
673            },
674            BlockNumberList::new([3, 7]).unwrap(),
675        )
676        .unwrap();
677        tx.put::<tables::StoragesHistory>(
678            StorageShardedKey {
679                address: ADDRESS,
680                sharded_key: ShardedKey { key: STORAGE, highest_block_number: u64::MAX },
681            },
682            BlockNumberList::new([10, 15]).unwrap(),
683        )
684        .unwrap();
685        tx.put::<tables::StoragesHistory>(
686            StorageShardedKey {
687                address: HIGHER_ADDRESS,
688                sharded_key: ShardedKey { key: STORAGE, highest_block_number: u64::MAX },
689            },
690            BlockNumberList::new([4]).unwrap(),
691        )
692        .unwrap();
693
694        let higher_entry_plain = StorageEntry { key: STORAGE, value: U256::from(1000) };
695        let higher_entry_at4 = StorageEntry { key: STORAGE, value: U256::from(0) };
696        let entry_plain = StorageEntry { key: STORAGE, value: U256::from(100) };
697        let entry_at15 = StorageEntry { key: STORAGE, value: U256::from(15) };
698        let entry_at10 = StorageEntry { key: STORAGE, value: U256::from(10) };
699        let entry_at7 = StorageEntry { key: STORAGE, value: U256::from(7) };
700        let entry_at3 = StorageEntry { key: STORAGE, value: U256::from(0) };
701
702        // setup
703        tx.put::<tables::StorageChangeSets>((3, ADDRESS).into(), entry_at3).unwrap();
704        tx.put::<tables::StorageChangeSets>((4, HIGHER_ADDRESS).into(), higher_entry_at4).unwrap();
705        tx.put::<tables::StorageChangeSets>((7, ADDRESS).into(), entry_at7).unwrap();
706        tx.put::<tables::StorageChangeSets>((10, ADDRESS).into(), entry_at10).unwrap();
707        tx.put::<tables::StorageChangeSets>((15, ADDRESS).into(), entry_at15).unwrap();
708
709        // setup plain state
710        tx.put::<tables::PlainStorageState>(ADDRESS, entry_plain).unwrap();
711        tx.put::<tables::PlainStorageState>(HIGHER_ADDRESS, higher_entry_plain).unwrap();
712        tx.commit().unwrap();
713
714        let db = factory.provider().unwrap();
715
716        // run
717        assert!(matches!(
718            HistoricalStateProviderRef::new(&db, 0).storage(ADDRESS, STORAGE),
719            Ok(None)
720        ));
721        assert!(matches!(
722            HistoricalStateProviderRef::new(&db, 3).storage(ADDRESS, STORAGE),
723            Ok(Some(U256::ZERO))
724        ));
725        assert!(matches!(
726            HistoricalStateProviderRef::new(&db, 4).storage(ADDRESS, STORAGE),
727            Ok(Some(expected_value)) if expected_value == entry_at7.value
728        ));
729        assert!(matches!(
730            HistoricalStateProviderRef::new(&db, 7).storage(ADDRESS, STORAGE),
731            Ok(Some(expected_value)) if expected_value == entry_at7.value
732        ));
733        assert!(matches!(
734            HistoricalStateProviderRef::new(&db, 9).storage(ADDRESS, STORAGE),
735            Ok(Some(expected_value)) if expected_value == entry_at10.value
736        ));
737        assert!(matches!(
738            HistoricalStateProviderRef::new(&db, 10).storage(ADDRESS, STORAGE),
739            Ok(Some(expected_value)) if expected_value == entry_at10.value
740        ));
741        assert!(matches!(
742            HistoricalStateProviderRef::new(&db, 11).storage(ADDRESS, STORAGE),
743            Ok(Some(expected_value)) if expected_value == entry_at15.value
744        ));
745        assert!(matches!(
746            HistoricalStateProviderRef::new(&db, 16).storage(ADDRESS, STORAGE),
747            Ok(Some(expected_value)) if expected_value == entry_plain.value
748        ));
749        assert!(matches!(
750            HistoricalStateProviderRef::new(&db, 1).storage(HIGHER_ADDRESS, STORAGE),
751            Ok(None)
752        ));
753        assert!(matches!(
754            HistoricalStateProviderRef::new(&db, 1000).storage(HIGHER_ADDRESS, STORAGE),
755            Ok(Some(expected_value)) if expected_value == higher_entry_plain.value
756        ));
757    }
758
759    #[test]
760    fn history_provider_unavailable() {
761        let factory = create_test_provider_factory();
762        let db = factory.database_provider_rw().unwrap();
763
764        // provider block_number < lowest available block number,
765        // i.e. state at provider block is pruned
766        let provider = HistoricalStateProviderRef::new_with_lowest_available_blocks(
767            &db,
768            2,
769            LowestAvailableBlocks {
770                account_history_block_number: Some(3),
771                storage_history_block_number: Some(3),
772            },
773        );
774        assert!(matches!(
775            provider.account_history_lookup(ADDRESS),
776            Err(ProviderError::StateAtBlockPruned(number)) if number == provider.block_number
777        ));
778        assert!(matches!(
779            provider.storage_history_lookup(ADDRESS, STORAGE),
780            Err(ProviderError::StateAtBlockPruned(number)) if number == provider.block_number
781        ));
782
783        // provider block_number == lowest available block number,
784        // i.e. state at provider block is available
785        let provider = HistoricalStateProviderRef::new_with_lowest_available_blocks(
786            &db,
787            2,
788            LowestAvailableBlocks {
789                account_history_block_number: Some(2),
790                storage_history_block_number: Some(2),
791            },
792        );
793        assert!(matches!(
794            provider.account_history_lookup(ADDRESS),
795            Ok(HistoryInfo::MaybeInPlainState)
796        ));
797        assert!(matches!(
798            provider.storage_history_lookup(ADDRESS, STORAGE),
799            Ok(HistoryInfo::MaybeInPlainState)
800        ));
801
802        // provider block_number == lowest available block number,
803        // i.e. state at provider block is available
804        let provider = HistoricalStateProviderRef::new_with_lowest_available_blocks(
805            &db,
806            2,
807            LowestAvailableBlocks {
808                account_history_block_number: Some(1),
809                storage_history_block_number: Some(1),
810            },
811        );
812        assert!(matches!(
813            provider.account_history_lookup(ADDRESS),
814            Ok(HistoryInfo::MaybeInPlainState)
815        ));
816        assert!(matches!(
817            provider.storage_history_lookup(ADDRESS, STORAGE),
818            Ok(HistoryInfo::MaybeInPlainState)
819        ));
820    }
821}
reth_provider/providers/state/historical.rs

reth_provider/providers/state/
historical.rs
