reth_provider/providers/state/
latest.rs

1use crate::{
2    AccountReader, BlockHashReader, HashedPostStateProvider, StateProvider, StateRootProvider,
3};
4use alloy_primitives::{Address, BlockNumber, Bytes, StorageKey, StorageValue, B256};
5use reth_db_api::{cursor::DbDupCursorRO, tables, transaction::DbTx};
6use reth_primitives_traits::{Account, Bytecode};
7use reth_storage_api::{
8    BytecodeReader, DBProvider, StateProofProvider, StorageRootProvider, StorageSettingsCache,
9};
10use reth_storage_errors::provider::{ProviderError, ProviderResult};
11use reth_trie::{
12    hashed_cursor::HashedPostStateCursorFactory,
13    proof::{Proof, StorageProof},
14    trie_cursor::InMemoryTrieCursorFactory,
15    updates::TrieUpdates,
16    witness::TrieWitness,
17    AccountProof, HashedPostState, HashedStorage, KeccakKeyHasher, MultiProof, MultiProofTargets,
18    StateRoot, StorageMultiProof, StorageRoot, TrieInput, TrieInputSorted,
19};
20use reth_trie_db::{DatabaseProof, DatabaseStateRoot, DatabaseStorageProof, DatabaseStorageRoot};
21
22type DbStateRoot<'a, TX, A> = StateRoot<
23    reth_trie_db::DatabaseTrieCursorFactory<&'a TX, A>,
24    reth_trie_db::DatabaseHashedCursorFactory<&'a TX>,
25>;
26type DbStorageRoot<'a, TX, A> = StorageRoot<
27    reth_trie_db::DatabaseTrieCursorFactory<&'a TX, A>,
28    reth_trie_db::DatabaseHashedCursorFactory<&'a TX>,
29>;
30type DbStorageProof<'a, TX, A> = StorageProof<
31    'static,
32    reth_trie_db::DatabaseTrieCursorFactory<&'a TX, A>,
33    reth_trie_db::DatabaseHashedCursorFactory<&'a TX>,
34>;
35type DbProof<'a, TX, A> = Proof<
36    reth_trie_db::DatabaseTrieCursorFactory<&'a TX, A>,
37    reth_trie_db::DatabaseHashedCursorFactory<&'a TX>,
38>;
39/// State provider over latest state that takes tx reference.
40///
41/// Wraps a [`DBProvider`] to get access to database.
42#[derive(Debug)]
43pub struct LatestStateProviderRef<'b, Provider>(&'b Provider);
44
45impl<'b, Provider: DBProvider> LatestStateProviderRef<'b, Provider> {
46    /// Create new state provider
47    pub const fn new(provider: &'b Provider) -> Self {
48        Self(provider)
49    }
50
51    fn tx(&self) -> &Provider::Tx {
52        self.0.tx_ref()
53    }
54
55    fn hashed_storage_lookup(
56        &self,
57        hashed_address: B256,
58        hashed_slot: StorageKey,
59    ) -> ProviderResult<Option<StorageValue>> {
60        let mut cursor = self.tx().cursor_dup_read::<tables::HashedStorages>()?;
61        Ok(cursor
62            .seek_by_key_subkey(hashed_address, hashed_slot)?
63            .filter(|e| e.key == hashed_slot)
64            .map(|e| e.value))
65    }
66}
67
68impl<Provider: DBProvider + StorageSettingsCache> AccountReader
69    for LatestStateProviderRef<'_, Provider>
70{
71    /// Get basic account information.
72    fn basic_account(&self, address: &Address) -> ProviderResult<Option<Account>> {
73        if self.0.cached_storage_settings().use_hashed_state() {
74            let hashed_address = alloy_primitives::keccak256(address);
75            self.tx()
76                .get_by_encoded_key::<tables::HashedAccounts>(&hashed_address)
77                .map_err(Into::into)
78        } else {
79            self.tx().get_by_encoded_key::<tables::PlainAccountState>(address).map_err(Into::into)
80        }
81    }
82}
83
84impl<Provider: BlockHashReader> BlockHashReader for LatestStateProviderRef<'_, Provider> {
85    /// Get block hash by number.
86    fn block_hash(&self, number: u64) -> ProviderResult<Option<B256>> {
87        self.0.block_hash(number)
88    }
89
90    fn canonical_hashes_range(
91        &self,
92        start: BlockNumber,
93        end: BlockNumber,
94    ) -> ProviderResult<Vec<B256>> {
95        self.0.canonical_hashes_range(start, end)
96    }
97}
98
99impl<Provider: DBProvider + StorageSettingsCache> StateRootProvider
100    for LatestStateProviderRef<'_, Provider>
101{
102    fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
103        reth_trie_db::with_adapter!(self.0, |A| {
104            let sorted = hashed_state.into_sorted();
105            Ok(<DbStateRoot<'_, _, A> as DatabaseStateRoot<_>>::overlay_root(self.tx(), &sorted)?)
106        })
107    }
108
109    fn state_root_from_nodes(&self, input: TrieInput) -> ProviderResult<B256> {
110        reth_trie_db::with_adapter!(self.0, |A| {
111            Ok(<DbStateRoot<'_, _, A> as DatabaseStateRoot<_>>::overlay_root_from_nodes(
112                self.tx(),
113                TrieInputSorted::from_unsorted(input),
114            )?)
115        })
116    }
117
118    fn state_root_with_updates(
119        &self,
120        hashed_state: HashedPostState,
121    ) -> ProviderResult<(B256, TrieUpdates)> {
122        reth_trie_db::with_adapter!(self.0, |A| {
123            let sorted = hashed_state.into_sorted();
124            Ok(<DbStateRoot<'_, _, A> as DatabaseStateRoot<_>>::overlay_root_with_updates(
125                self.tx(),
126                &sorted,
127            )?)
128        })
129    }
130
131    fn state_root_from_nodes_with_updates(
132        &self,
133        input: TrieInput,
134    ) -> ProviderResult<(B256, TrieUpdates)> {
135        reth_trie_db::with_adapter!(self.0, |A| {
136            Ok(
137                <DbStateRoot<'_, _, A> as DatabaseStateRoot<_>>::overlay_root_from_nodes_with_updates(
138                    self.tx(),
139                    TrieInputSorted::from_unsorted(input),
140                )?,
141            )
142        })
143    }
144}
145
146impl<Provider: DBProvider + StorageSettingsCache> StorageRootProvider
147    for LatestStateProviderRef<'_, Provider>
148{
149    fn storage_root(
150        &self,
151        address: Address,
152        hashed_storage: HashedStorage,
153    ) -> ProviderResult<B256> {
154        reth_trie_db::with_adapter!(self.0, |A| {
155            <DbStorageRoot<'_, _, A>>::overlay_root(self.tx(), address, hashed_storage)
156                .map_err(|err| ProviderError::Database(err.into()))
157        })
158    }
159
160    fn storage_proof(
161        &self,
162        address: Address,
163        slot: B256,
164        hashed_storage: HashedStorage,
165    ) -> ProviderResult<reth_trie::StorageProof> {
166        reth_trie_db::with_adapter!(self.0, |A| {
167            <DbStorageProof<'_, _, A>>::overlay_storage_proof(
168                self.tx(),
169                address,
170                slot,
171                hashed_storage,
172            )
173            .map_err(ProviderError::from)
174        })
175    }
176
177    fn storage_multiproof(
178        &self,
179        address: Address,
180        slots: &[B256],
181        hashed_storage: HashedStorage,
182    ) -> ProviderResult<StorageMultiProof> {
183        reth_trie_db::with_adapter!(self.0, |A| {
184            <DbStorageProof<'_, _, A>>::overlay_storage_multiproof(
185                self.tx(),
186                address,
187                slots,
188                hashed_storage,
189            )
190            .map_err(ProviderError::from)
191        })
192    }
193}
194
195impl<Provider: DBProvider + StorageSettingsCache> StateProofProvider
196    for LatestStateProviderRef<'_, Provider>
197{
198    fn proof(
199        &self,
200        input: TrieInput,
201        address: Address,
202        slots: &[B256],
203    ) -> ProviderResult<AccountProof> {
204        reth_trie_db::with_adapter!(self.0, |A| {
205            let proof = <DbProof<'_, _, A> as DatabaseProof>::from_tx(self.tx());
206            proof.overlay_account_proof(input, address, slots).map_err(ProviderError::from)
207        })
208    }
209
210    fn multiproof(
211        &self,
212        input: TrieInput,
213        targets: MultiProofTargets,
214    ) -> ProviderResult<MultiProof> {
215        reth_trie_db::with_adapter!(self.0, |A| {
216            let proof = <DbProof<'_, _, A> as DatabaseProof>::from_tx(self.tx());
217            proof.overlay_multiproof(input, targets).map_err(ProviderError::from)
218        })
219    }
220
221    fn witness(&self, input: TrieInput, target: HashedPostState) -> ProviderResult<Vec<Bytes>> {
222        reth_trie_db::with_adapter!(self.0, |A| {
223            let nodes_sorted = input.nodes.into_sorted();
224            let state_sorted = input.state.into_sorted();
225            Ok(TrieWitness::new(
226                InMemoryTrieCursorFactory::new(
227                    reth_trie_db::DatabaseTrieCursorFactory::<_, A>::new(self.tx()),
228                    &nodes_sorted,
229                ),
230                HashedPostStateCursorFactory::new(
231                    reth_trie_db::DatabaseHashedCursorFactory::new(self.tx()),
232                    &state_sorted,
233                ),
234            )
235            .with_prefix_sets_mut(input.prefix_sets)
236            .always_include_root_node()
237            .compute(target)?
238            .into_values()
239            .collect())
240        })
241    }
242}
243
244impl<Provider: DBProvider> HashedPostStateProvider for LatestStateProviderRef<'_, Provider> {
245    fn hashed_post_state(&self, bundle_state: &revm_database::BundleState) -> HashedPostState {
246        HashedPostState::from_bundle_state::<KeccakKeyHasher>(bundle_state.state())
247    }
248}
249
250impl<Provider: DBProvider + BlockHashReader + StorageSettingsCache> StateProvider
251    for LatestStateProviderRef<'_, Provider>
252{
253    /// Get storage by plain (unhashed) storage key slot.
254    fn storage(
255        &self,
256        account: Address,
257        storage_key: StorageKey,
258    ) -> ProviderResult<Option<StorageValue>> {
259        if self.0.cached_storage_settings().use_hashed_state() {
260            self.hashed_storage_lookup(
261                alloy_primitives::keccak256(account),
262                alloy_primitives::keccak256(storage_key),
263            )
264        } else {
265            let mut cursor = self.tx().cursor_dup_read::<tables::PlainStorageState>()?;
266            if let Some(entry) = cursor.seek_by_key_subkey(account, storage_key)? &&
267                entry.key == storage_key
268            {
269                return Ok(Some(entry.value));
270            }
271            Ok(None)
272        }
273    }
274}
275
276impl<Provider: DBProvider + BlockHashReader> BytecodeReader
277    for LatestStateProviderRef<'_, Provider>
278{
279    /// Get account code by its hash
280    fn bytecode_by_hash(&self, code_hash: &B256) -> ProviderResult<Option<Bytecode>> {
281        self.tx().get_by_encoded_key::<tables::Bytecodes>(code_hash).map_err(Into::into)
282    }
283}
284
285/// State provider for the latest state.
286#[derive(Debug)]
287pub struct LatestStateProvider<Provider>(Provider);
288
289impl<Provider: DBProvider> LatestStateProvider<Provider> {
290    /// Create new state provider
291    pub const fn new(db: Provider) -> Self {
292        Self(db)
293    }
294
295    /// Returns a new provider that takes the `TX` as reference
296    #[inline(always)]
297    const fn as_ref(&self) -> LatestStateProviderRef<'_, Provider> {
298        LatestStateProviderRef::new(&self.0)
299    }
300}
301
302// Delegates all provider impls to [LatestStateProviderRef]
303reth_storage_api::macros::delegate_provider_impls!(LatestStateProvider<Provider> where [Provider: DBProvider + BlockHashReader + StorageSettingsCache]);
304
305#[cfg(test)]
306mod tests {
307    use super::*;
308    use crate::test_utils::create_test_provider_factory;
309    use alloy_primitives::{address, b256, keccak256, U256};
310    use reth_db_api::{
311        models::StorageSettings,
312        tables,
313        transaction::{DbTx, DbTxMut},
314    };
315    use reth_primitives_traits::StorageEntry;
316    use reth_storage_api::StorageSettingsCache;
317
318    const fn assert_state_provider<T: StateProvider>() {}
319    #[expect(dead_code)]
320    const fn assert_latest_state_provider<
321        T: DBProvider + BlockHashReader + StorageSettingsCache,
322    >() {
323        assert_state_provider::<LatestStateProvider<T>>();
324    }
325
326    #[test]
327    fn test_latest_storage_hashed_state() {
328        let factory = create_test_provider_factory();
329        factory.set_storage_settings_cache(StorageSettings::v2());
330
331        let address = address!("0x0000000000000000000000000000000000000001");
332        let slot = b256!("0x0000000000000000000000000000000000000000000000000000000000000001");
333
334        let hashed_address = keccak256(address);
335        let hashed_slot = keccak256(slot);
336
337        let tx = factory.provider_rw().unwrap().into_tx();
338        tx.put::<tables::HashedStorages>(
339            hashed_address,
340            StorageEntry { key: hashed_slot, value: U256::from(42) },
341        )
342        .unwrap();
343        tx.commit().unwrap();
344
345        let db = factory.provider().unwrap();
346        let provider_ref = LatestStateProviderRef::new(&db);
347
348        assert_eq!(provider_ref.storage(address, slot).unwrap(), Some(U256::from(42)));
349
350        let other_address = address!("0x0000000000000000000000000000000000000099");
351        let other_slot =
352            b256!("0x0000000000000000000000000000000000000000000000000000000000000099");
353        assert_eq!(provider_ref.storage(other_address, other_slot).unwrap(), None);
354
355        let tx = factory.provider_rw().unwrap().into_tx();
356        let plain_address = address!("0x0000000000000000000000000000000000000002");
357        let plain_slot =
358            b256!("0x0000000000000000000000000000000000000000000000000000000000000002");
359        tx.put::<tables::PlainStorageState>(
360            plain_address,
361            StorageEntry { key: plain_slot, value: U256::from(99) },
362        )
363        .unwrap();
364        tx.commit().unwrap();
365
366        let db = factory.provider().unwrap();
367        let provider_ref = LatestStateProviderRef::new(&db);
368        assert_eq!(provider_ref.storage(plain_address, plain_slot).unwrap(), None);
369    }
370
371    #[test]
372    fn test_latest_storage_hashed_state_returns_none_for_missing() {
373        let factory = create_test_provider_factory();
374        factory.set_storage_settings_cache(StorageSettings::v2());
375
376        let address = address!("0x0000000000000000000000000000000000000001");
377        let slot = b256!("0x0000000000000000000000000000000000000000000000000000000000000001");
378
379        let db = factory.provider().unwrap();
380        let provider_ref = LatestStateProviderRef::new(&db);
381        assert_eq!(provider_ref.storage(address, slot).unwrap(), None);
382    }
383
384    #[test]
385    fn test_latest_storage_legacy() {
386        let factory = create_test_provider_factory();
387        assert!(!factory.provider().unwrap().cached_storage_settings().use_hashed_state());
388
389        let address = address!("0x0000000000000000000000000000000000000001");
390        let slot = b256!("0x0000000000000000000000000000000000000000000000000000000000000005");
391
392        let tx = factory.provider_rw().unwrap().into_tx();
393        tx.put::<tables::PlainStorageState>(
394            address,
395            StorageEntry { key: slot, value: U256::from(42) },
396        )
397        .unwrap();
398        tx.commit().unwrap();
399
400        let db = factory.provider().unwrap();
401        let provider_ref = LatestStateProviderRef::new(&db);
402
403        assert_eq!(provider_ref.storage(address, slot).unwrap(), Some(U256::from(42)));
404
405        let other_slot =
406            b256!("0x0000000000000000000000000000000000000000000000000000000000000099");
407        assert_eq!(provider_ref.storage(address, other_slot).unwrap(), None);
408    }
409
410    #[test]
411    fn test_latest_storage_legacy_does_not_read_hashed() {
412        let factory = create_test_provider_factory();
413        assert!(!factory.provider().unwrap().cached_storage_settings().use_hashed_state());
414
415        let address = address!("0x0000000000000000000000000000000000000001");
416        let slot = b256!("0x0000000000000000000000000000000000000000000000000000000000000005");
417        let hashed_address = keccak256(address);
418        let hashed_slot = keccak256(slot);
419
420        let tx = factory.provider_rw().unwrap().into_tx();
421        tx.put::<tables::HashedStorages>(
422            hashed_address,
423            StorageEntry { key: hashed_slot, value: U256::from(42) },
424        )
425        .unwrap();
426        tx.commit().unwrap();
427
428        let db = factory.provider().unwrap();
429        let provider_ref = LatestStateProviderRef::new(&db);
430        assert_eq!(provider_ref.storage(address, slot).unwrap(), None);
431    }
432}
reth_provider/providers/state/latest.rs

reth_provider/providers/state/
latest.rs
