reth_storage_api/
noop.rs

1//! Various noop implementations for traits.
2
3pub use crate::bal::NoopBalStore;
4
5use crate::{
6    AccountReader, BalProvider, BalStoreHandle, BlockBodyIndicesProvider, BlockHashReader,
7    BlockIdReader, BlockNumReader, BlockReader, BlockReaderIdExt, BlockSource, BytecodeReader,
8    ChangeSetReader, HashedPostStateProvider, HeaderProvider, NodePrimitivesProvider,
9    PruneCheckpointReader, ReceiptProvider, ReceiptProviderIdExt, StageCheckpointReader,
10    StateProofProvider, StateProvider, StateProviderBox, StateProviderFactory,
11    StateRangeProviderFactory, StateRangeView, StateReader, StateRootProvider, StorageRootProvider,
12    TransactionVariant, TransactionsProvider,
13};
14
15#[cfg(feature = "db-api")]
16use crate::{DBProvider, DatabaseProviderFactory, StorageChangeSetReader, StorageSettingsCache};
17use alloc::{boxed::Box, string::String, sync::Arc, vec::Vec};
18use alloy_consensus::transaction::TransactionMeta;
19use alloy_eips::{BlockHashOrNumber, BlockId, BlockNumberOrTag};
20use alloy_primitives::{
21    Address, BlockHash, BlockNumber, Bytes, StorageKey, StorageValue, TxHash, TxNumber, B256,
22};
23use core::{
24    fmt::Debug,
25    marker::PhantomData,
26    ops::{RangeBounds, RangeInclusive},
27};
28use reth_chainspec::{ChainInfo, ChainSpecProvider, EthChainSpec, MAINNET};
29#[cfg(feature = "db-api")]
30use reth_db_api::mock::{DatabaseMock, TxMock};
31use reth_db_models::{AccountBeforeTx, StoredBlockBodyIndices};
32use reth_ethereum_primitives::EthPrimitives;
33use reth_execution_types::ExecutionOutcome;
34use reth_primitives_traits::{Account, Bytecode, NodePrimitives, RecoveredBlock, SealedHeader};
35#[cfg(feature = "db-api")]
36use reth_prune_types::PruneModes;
37use reth_prune_types::{PruneCheckpoint, PruneSegment};
38use reth_stages_types::{StageCheckpoint, StageId};
39use reth_storage_errors::provider::{ProviderError, ProviderResult};
40use reth_trie_common::{
41    updates::TrieUpdates, AccountProof, ExecutionWitnessMode, HashedPostState, HashedStorage,
42    MultiProof, MultiProofTargets, StorageMultiProof, StorageProof, TrieInput,
43};
44
45/// Supports various api interfaces for testing purposes.
46#[derive(Debug)]
47#[non_exhaustive]
48pub struct NoopProvider<ChainSpec = reth_chainspec::ChainSpec, N = EthPrimitives> {
49    chain_spec: Arc<ChainSpec>,
50    bal_store: BalStoreHandle,
51    #[cfg(feature = "db-api")]
52    tx: TxMock,
53    #[cfg(feature = "db-api")]
54    prune_modes: PruneModes,
55    _phantom: PhantomData<N>,
56}
57
58impl<ChainSpec, N> NoopProvider<ChainSpec, N> {
59    /// Create a new instance for specific primitive types.
60    pub fn new(chain_spec: Arc<ChainSpec>) -> Self {
61        Self {
62            chain_spec,
63            bal_store: BalStoreHandle::default(),
64            #[cfg(feature = "db-api")]
65            tx: TxMock::default(),
66            #[cfg(feature = "db-api")]
67            prune_modes: PruneModes::default(),
68            _phantom: Default::default(),
69        }
70    }
71}
72
73impl<ChainSpec> NoopProvider<ChainSpec> {
74    /// Create a new instance of the `NoopBlockReader`.
75    pub fn eth(chain_spec: Arc<ChainSpec>) -> Self {
76        Self {
77            chain_spec,
78            bal_store: BalStoreHandle::default(),
79            #[cfg(feature = "db-api")]
80            tx: TxMock::default(),
81            #[cfg(feature = "db-api")]
82            prune_modes: PruneModes::default(),
83            _phantom: Default::default(),
84        }
85    }
86}
87
88impl NoopProvider {
89    /// Create a new instance of the [`NoopProvider`] with the mainnet chain spec.
90    pub fn mainnet() -> Self {
91        Self::eth(MAINNET.clone())
92    }
93}
94
95impl Default for NoopProvider {
96    fn default() -> Self {
97        Self::mainnet()
98    }
99}
100
101impl<ChainSpec, N> Clone for NoopProvider<ChainSpec, N> {
102    fn clone(&self) -> Self {
103        Self {
104            chain_spec: Arc::clone(&self.chain_spec),
105            bal_store: self.bal_store.clone(),
106            #[cfg(feature = "db-api")]
107            tx: self.tx.clone(),
108            #[cfg(feature = "db-api")]
109            prune_modes: self.prune_modes.clone(),
110            _phantom: Default::default(),
111        }
112    }
113}
114
115impl<ChainSpec, N> BalProvider for NoopProvider<ChainSpec, N> {
116    fn bal_store(&self) -> &BalStoreHandle {
117        &self.bal_store
118    }
119}
120
121impl<ChainSpec, N> StateRangeProviderFactory for NoopProvider<ChainSpec, N> {
122    fn state_range_provider(&self, _state_root: B256) -> ProviderResult<Option<StateRangeView>> {
123        Ok(None)
124    }
125}
126
127/// Noop implementation for testing purposes
128impl<ChainSpec: Send + Sync, N: Send + Sync> BlockHashReader for NoopProvider<ChainSpec, N> {
129    fn block_hash(&self, _number: u64) -> ProviderResult<Option<B256>> {
130        Ok(None)
131    }
132
133    fn canonical_hashes_range(
134        &self,
135        _start: BlockNumber,
136        _end: BlockNumber,
137    ) -> ProviderResult<Vec<B256>> {
138        Ok(Vec::new())
139    }
140}
141
142impl<ChainSpec: Send + Sync, N: Send + Sync> BlockNumReader for NoopProvider<ChainSpec, N> {
143    fn chain_info(&self) -> ProviderResult<ChainInfo> {
144        Ok(ChainInfo::default())
145    }
146
147    fn best_block_number(&self) -> ProviderResult<BlockNumber> {
148        Ok(0)
149    }
150
151    fn last_block_number(&self) -> ProviderResult<BlockNumber> {
152        Ok(0)
153    }
154
155    fn block_number(&self, _hash: B256) -> ProviderResult<Option<BlockNumber>> {
156        Ok(None)
157    }
158}
159
160impl<ChainSpec: EthChainSpec + 'static, N: Debug + Send + Sync + 'static> ChainSpecProvider
161    for NoopProvider<ChainSpec, N>
162{
163    type ChainSpec = ChainSpec;
164
165    fn chain_spec(&self) -> Arc<Self::ChainSpec> {
166        self.chain_spec.clone()
167    }
168}
169
170impl<C: Send + Sync, N: NodePrimitives> BlockIdReader for NoopProvider<C, N> {
171    fn pending_block_num_hash(&self) -> ProviderResult<Option<alloy_eips::BlockNumHash>> {
172        Ok(None)
173    }
174
175    fn safe_block_num_hash(&self) -> ProviderResult<Option<alloy_eips::BlockNumHash>> {
176        Ok(None)
177    }
178
179    fn finalized_block_num_hash(&self) -> ProviderResult<Option<alloy_eips::BlockNumHash>> {
180        Ok(None)
181    }
182}
183
184impl<C: Send + Sync, N: NodePrimitives> BlockReaderIdExt for NoopProvider<C, N> {
185    fn block_by_id(&self, _id: BlockId) -> ProviderResult<Option<N::Block>> {
186        Ok(None)
187    }
188
189    fn sealed_header_by_id(
190        &self,
191        _id: BlockId,
192    ) -> ProviderResult<Option<SealedHeader<N::BlockHeader>>> {
193        Ok(None)
194    }
195
196    fn header_by_id(&self, _id: BlockId) -> ProviderResult<Option<N::BlockHeader>> {
197        Ok(None)
198    }
199}
200
201impl<C: Send + Sync, N: NodePrimitives> BlockReader for NoopProvider<C, N> {
202    type Block = N::Block;
203
204    fn find_block_by_hash(
205        &self,
206        _hash: B256,
207        _source: BlockSource,
208    ) -> ProviderResult<Option<Self::Block>> {
209        Ok(None)
210    }
211
212    fn block(&self, _id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>> {
213        Ok(None)
214    }
215
216    fn pending_block(&self) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
217        Ok(None)
218    }
219
220    fn pending_block_and_receipts(
221        &self,
222    ) -> ProviderResult<Option<(RecoveredBlock<Self::Block>, Vec<Self::Receipt>)>> {
223        Ok(None)
224    }
225
226    fn recovered_block(
227        &self,
228        _id: BlockHashOrNumber,
229        _transaction_kind: TransactionVariant,
230    ) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
231        Ok(None)
232    }
233
234    fn sealed_block_with_senders(
235        &self,
236        _id: BlockHashOrNumber,
237        _transaction_kind: TransactionVariant,
238    ) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
239        Ok(None)
240    }
241
242    fn block_range(&self, _range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Self::Block>> {
243        Ok(Vec::new())
244    }
245
246    fn block_with_senders_range(
247        &self,
248        _range: RangeInclusive<BlockNumber>,
249    ) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
250        Ok(Vec::new())
251    }
252
253    fn recovered_block_range(
254        &self,
255        _range: RangeInclusive<BlockNumber>,
256    ) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
257        Ok(Vec::new())
258    }
259
260    fn block_by_transaction_id(&self, _id: TxNumber) -> ProviderResult<Option<BlockNumber>> {
261        Ok(None)
262    }
263}
264
265impl<C: Send + Sync, N: NodePrimitives> TransactionsProvider for NoopProvider<C, N> {
266    type Transaction = N::SignedTx;
267
268    fn transaction_id(&self, _tx_hash: TxHash) -> ProviderResult<Option<TxNumber>> {
269        Ok(None)
270    }
271
272    fn transaction_by_id(&self, _id: TxNumber) -> ProviderResult<Option<Self::Transaction>> {
273        Ok(None)
274    }
275
276    fn transaction_by_id_unhashed(
277        &self,
278        _id: TxNumber,
279    ) -> ProviderResult<Option<Self::Transaction>> {
280        Ok(None)
281    }
282
283    fn transaction_by_hash(&self, _hash: TxHash) -> ProviderResult<Option<Self::Transaction>> {
284        Ok(None)
285    }
286
287    fn transaction_by_hash_with_meta(
288        &self,
289        _hash: TxHash,
290    ) -> ProviderResult<Option<(Self::Transaction, TransactionMeta)>> {
291        Ok(None)
292    }
293
294    fn transactions_by_block(
295        &self,
296        _block_id: BlockHashOrNumber,
297    ) -> ProviderResult<Option<Vec<Self::Transaction>>> {
298        Ok(None)
299    }
300
301    fn transactions_by_block_range(
302        &self,
303        _range: impl RangeBounds<BlockNumber>,
304    ) -> ProviderResult<Vec<Vec<Self::Transaction>>> {
305        Ok(Vec::default())
306    }
307
308    fn transactions_by_tx_range(
309        &self,
310        _range: impl RangeBounds<TxNumber>,
311    ) -> ProviderResult<Vec<Self::Transaction>> {
312        Ok(Vec::default())
313    }
314
315    fn senders_by_tx_range(
316        &self,
317        _range: impl RangeBounds<TxNumber>,
318    ) -> ProviderResult<Vec<Address>> {
319        Ok(Vec::default())
320    }
321
322    fn transaction_sender(&self, _id: TxNumber) -> ProviderResult<Option<Address>> {
323        Ok(None)
324    }
325}
326
327impl<C: Send + Sync, N: NodePrimitives> ReceiptProvider for NoopProvider<C, N> {
328    type Receipt = N::Receipt;
329
330    fn receipt(&self, _id: TxNumber) -> ProviderResult<Option<Self::Receipt>> {
331        Ok(None)
332    }
333
334    fn receipt_by_hash(&self, _hash: TxHash) -> ProviderResult<Option<Self::Receipt>> {
335        Ok(None)
336    }
337
338    fn receipts_by_block(
339        &self,
340        _block: BlockHashOrNumber,
341    ) -> ProviderResult<Option<Vec<Self::Receipt>>> {
342        Ok(None)
343    }
344
345    fn receipts_by_tx_range(
346        &self,
347        _range: impl RangeBounds<TxNumber>,
348    ) -> ProviderResult<Vec<Self::Receipt>> {
349        Ok(Vec::new())
350    }
351
352    fn receipts_by_block_range(
353        &self,
354        _block_range: RangeInclusive<BlockNumber>,
355    ) -> ProviderResult<Vec<Vec<Self::Receipt>>> {
356        Ok(Vec::new())
357    }
358}
359
360impl<C: Send + Sync, N: NodePrimitives> ReceiptProviderIdExt for NoopProvider<C, N> {}
361
362impl<C: Send + Sync, N: NodePrimitives> HeaderProvider for NoopProvider<C, N> {
363    type Header = N::BlockHeader;
364
365    fn header(&self, _block_hash: BlockHash) -> ProviderResult<Option<Self::Header>> {
366        Ok(None)
367    }
368
369    fn header_by_number(&self, _num: u64) -> ProviderResult<Option<Self::Header>> {
370        Ok(None)
371    }
372
373    fn headers_range(
374        &self,
375        _range: impl RangeBounds<BlockNumber>,
376    ) -> ProviderResult<Vec<Self::Header>> {
377        Ok(Vec::new())
378    }
379
380    fn sealed_header(
381        &self,
382        _number: BlockNumber,
383    ) -> ProviderResult<Option<SealedHeader<Self::Header>>> {
384        Ok(None)
385    }
386
387    fn sealed_headers_while(
388        &self,
389        _range: impl RangeBounds<BlockNumber>,
390        _predicate: impl FnMut(&SealedHeader<Self::Header>) -> bool,
391    ) -> ProviderResult<Vec<SealedHeader<Self::Header>>> {
392        Ok(Vec::new())
393    }
394}
395
396impl<C: Send + Sync, N: NodePrimitives> AccountReader for NoopProvider<C, N> {
397    fn basic_account(&self, _address: &Address) -> ProviderResult<Option<Account>> {
398        Ok(None)
399    }
400}
401
402impl<C: Send + Sync, N: NodePrimitives> ChangeSetReader for NoopProvider<C, N> {
403    fn account_block_changeset(
404        &self,
405        _block_number: BlockNumber,
406    ) -> ProviderResult<Vec<AccountBeforeTx>> {
407        Ok(Vec::default())
408    }
409
410    fn get_account_before_block(
411        &self,
412        _block_number: BlockNumber,
413        _address: Address,
414    ) -> ProviderResult<Option<AccountBeforeTx>> {
415        Ok(None)
416    }
417
418    fn account_changesets_range(
419        &self,
420        _range: impl core::ops::RangeBounds<BlockNumber>,
421    ) -> ProviderResult<Vec<(BlockNumber, AccountBeforeTx)>> {
422        Ok(Vec::default())
423    }
424}
425
426#[cfg(feature = "db-api")]
427impl<C: Send + Sync, N: NodePrimitives> StorageChangeSetReader for NoopProvider<C, N> {
428    fn storage_changeset(
429        &self,
430        _block_number: BlockNumber,
431    ) -> ProviderResult<
432        Vec<(reth_db_api::models::BlockNumberAddress, reth_primitives_traits::StorageEntry)>,
433    > {
434        Ok(Vec::default())
435    }
436
437    fn get_storage_before_block(
438        &self,
439        _block_number: BlockNumber,
440        _address: Address,
441        _storage_key: B256,
442    ) -> ProviderResult<Option<reth_primitives_traits::StorageEntry>> {
443        Ok(None)
444    }
445
446    fn storage_changesets_range(
447        &self,
448        _range: impl core::ops::RangeBounds<BlockNumber>,
449    ) -> ProviderResult<
450        Vec<(reth_db_api::models::BlockNumberAddress, reth_primitives_traits::StorageEntry)>,
451    > {
452        Ok(Vec::default())
453    }
454}
455
456impl<C: Send + Sync, N: NodePrimitives> StateRootProvider for NoopProvider<C, N> {
457    fn state_root(&self, _state: HashedPostState) -> ProviderResult<B256> {
458        Ok(B256::default())
459    }
460
461    fn state_root_from_nodes(&self, _input: TrieInput) -> ProviderResult<B256> {
462        Ok(B256::default())
463    }
464
465    fn state_root_with_updates(
466        &self,
467        _state: HashedPostState,
468    ) -> ProviderResult<(B256, TrieUpdates)> {
469        Ok((B256::default(), TrieUpdates::default()))
470    }
471
472    fn state_root_from_nodes_with_updates(
473        &self,
474        _input: TrieInput,
475    ) -> ProviderResult<(B256, TrieUpdates)> {
476        Ok((B256::default(), TrieUpdates::default()))
477    }
478}
479
480impl<C: Send + Sync, N: NodePrimitives> StorageRootProvider for NoopProvider<C, N> {
481    fn storage_root(
482        &self,
483        _address: Address,
484        _hashed_storage: HashedStorage,
485    ) -> ProviderResult<B256> {
486        Ok(B256::default())
487    }
488
489    fn storage_proof(
490        &self,
491        _address: Address,
492        slot: B256,
493        _hashed_storage: HashedStorage,
494    ) -> ProviderResult<StorageProof> {
495        Ok(StorageProof::new(slot))
496    }
497
498    fn storage_multiproof(
499        &self,
500        _address: Address,
501        _slots: &[B256],
502        _hashed_storage: HashedStorage,
503    ) -> ProviderResult<StorageMultiProof> {
504        Ok(StorageMultiProof::empty())
505    }
506}
507
508impl<C: Send + Sync, N: NodePrimitives> StateProofProvider for NoopProvider<C, N> {
509    fn proof(
510        &self,
511        _input: TrieInput,
512        address: Address,
513        _slots: &[B256],
514    ) -> ProviderResult<AccountProof> {
515        Ok(AccountProof::new(address))
516    }
517
518    fn multiproof(
519        &self,
520        _input: TrieInput,
521        _targets: MultiProofTargets,
522    ) -> ProviderResult<MultiProof> {
523        Ok(MultiProof::default())
524    }
525
526    fn witness(
527        &self,
528        _input: TrieInput,
529        _target: HashedPostState,
530        _mode: ExecutionWitnessMode,
531    ) -> ProviderResult<Vec<Bytes>> {
532        Ok(Vec::default())
533    }
534}
535
536impl<C: Send + Sync, N: NodePrimitives> HashedPostStateProvider for NoopProvider<C, N> {
537    fn hashed_post_state(&self, _bundle_state: &revm::database::BundleState) -> HashedPostState {
538        HashedPostState::default()
539    }
540}
541
542impl<C: Send + Sync, N: NodePrimitives> StateReader for NoopProvider<C, N> {
543    type Receipt = N::Receipt;
544
545    fn get_state(
546        &self,
547        _block: BlockNumber,
548    ) -> ProviderResult<Option<ExecutionOutcome<Self::Receipt>>> {
549        Ok(None)
550    }
551}
552
553impl<C: Send + Sync, N: NodePrimitives> StateProvider for NoopProvider<C, N> {
554    fn storage(
555        &self,
556        _account: Address,
557        _storage_key: StorageKey,
558    ) -> ProviderResult<Option<StorageValue>> {
559        Ok(None)
560    }
561}
562
563impl<C: Send + Sync, N: NodePrimitives> BytecodeReader for NoopProvider<C, N> {
564    fn bytecode_by_hash(&self, _code_hash: &B256) -> ProviderResult<Option<Bytecode>> {
565        Ok(None)
566    }
567}
568
569impl<C: Send + Sync + 'static, N: NodePrimitives> StateProviderFactory for NoopProvider<C, N> {
570    fn latest(&self) -> ProviderResult<StateProviderBox> {
571        Ok(Box::new(self.clone()))
572    }
573
574    fn state_by_block_number_or_tag(
575        &self,
576        number_or_tag: BlockNumberOrTag,
577    ) -> ProviderResult<StateProviderBox> {
578        match number_or_tag {
579            BlockNumberOrTag::Latest => self.latest(),
580            BlockNumberOrTag::Finalized => {
581                // we can only get the finalized state by hash, not by num
582                let hash =
583                    self.finalized_block_hash()?.ok_or(ProviderError::FinalizedBlockNotFound)?;
584
585                // only look at historical state
586                self.history_by_block_hash(hash)
587            }
588            BlockNumberOrTag::Safe => {
589                // we can only get the safe state by hash, not by num
590                let hash = self.safe_block_hash()?.ok_or(ProviderError::SafeBlockNotFound)?;
591
592                self.history_by_block_hash(hash)
593            }
594            BlockNumberOrTag::Earliest => {
595                self.history_by_block_number(self.earliest_block_number()?)
596            }
597            BlockNumberOrTag::Pending => self.pending(),
598            BlockNumberOrTag::Number(num) => self.history_by_block_number(num),
599        }
600    }
601
602    fn history_by_block_number(&self, _block: BlockNumber) -> ProviderResult<StateProviderBox> {
603        Ok(Box::new(self.clone()))
604    }
605
606    fn history_by_block_hash(&self, _block: BlockHash) -> ProviderResult<StateProviderBox> {
607        Ok(Box::new(self.clone()))
608    }
609
610    fn state_by_block_hash(&self, _block: BlockHash) -> ProviderResult<StateProviderBox> {
611        Ok(Box::new(self.clone()))
612    }
613
614    fn pending(&self) -> ProviderResult<StateProviderBox> {
615        Ok(Box::new(self.clone()))
616    }
617
618    fn pending_state_by_hash(&self, _block_hash: B256) -> ProviderResult<Option<StateProviderBox>> {
619        Ok(Some(Box::new(self.clone())))
620    }
621
622    fn maybe_pending(&self) -> ProviderResult<Option<StateProviderBox>> {
623        Ok(Some(Box::new(self.clone())))
624    }
625}
626
627impl<C: Send + Sync, N: NodePrimitives> StageCheckpointReader for NoopProvider<C, N> {
628    fn get_stage_checkpoint(&self, _id: StageId) -> ProviderResult<Option<StageCheckpoint>> {
629        Ok(None)
630    }
631
632    fn get_stage_checkpoint_progress(&self, _id: StageId) -> ProviderResult<Option<Vec<u8>>> {
633        Ok(None)
634    }
635
636    fn get_all_checkpoints(&self) -> ProviderResult<Vec<(String, StageCheckpoint)>> {
637        Ok(Vec::new())
638    }
639}
640
641impl<C: Send + Sync, N: NodePrimitives> PruneCheckpointReader for NoopProvider<C, N> {
642    fn get_prune_checkpoint(
643        &self,
644        _segment: PruneSegment,
645    ) -> ProviderResult<Option<PruneCheckpoint>> {
646        Ok(None)
647    }
648
649    fn get_prune_checkpoints(&self) -> ProviderResult<Vec<(PruneSegment, PruneCheckpoint)>> {
650        Ok(Vec::new())
651    }
652}
653
654impl<C: Send + Sync, N: NodePrimitives> NodePrimitivesProvider for NoopProvider<C, N> {
655    type Primitives = N;
656}
657
658impl<C: Send + Sync, N: Send + Sync> BlockBodyIndicesProvider for NoopProvider<C, N> {
659    fn block_body_indices(&self, _num: u64) -> ProviderResult<Option<StoredBlockBodyIndices>> {
660        Ok(None)
661    }
662
663    fn block_body_indices_range(
664        &self,
665        _range: RangeInclusive<BlockNumber>,
666    ) -> ProviderResult<Vec<StoredBlockBodyIndices>> {
667        Ok(Vec::new())
668    }
669}
670
671#[cfg(feature = "db-api")]
672impl<ChainSpec: Send + Sync, N: NodePrimitives> DBProvider for NoopProvider<ChainSpec, N> {
673    type Tx = TxMock;
674
675    fn tx_ref(&self) -> &Self::Tx {
676        &self.tx
677    }
678
679    fn tx_mut(&mut self) -> &mut Self::Tx {
680        &mut self.tx
681    }
682
683    fn into_tx(self) -> Self::Tx {
684        self.tx
685    }
686
687    fn prune_modes_ref(&self) -> &PruneModes {
688        &self.prune_modes
689    }
690
691    fn commit(self) -> ProviderResult<()> {
692        use reth_db_api::transaction::DbTx;
693
694        Ok(self.tx.commit()?)
695    }
696}
697
698#[cfg(feature = "db-api")]
699impl<ChainSpec: Send + Sync, N: NodePrimitives> DatabaseProviderFactory
700    for NoopProvider<ChainSpec, N>
701{
702    type DB = DatabaseMock;
703    type Provider = Self;
704    type ProviderRW = Self;
705
706    fn database_provider_ro(&self) -> ProviderResult<Self::Provider> {
707        Ok(self.clone())
708    }
709
710    fn database_provider_rw(&self) -> ProviderResult<Self::ProviderRW> {
711        Ok(self.clone())
712    }
713}
714
715#[cfg(feature = "db-api")]
716impl<ChainSpec: Send + Sync, N: Send + Sync> StorageSettingsCache for NoopProvider<ChainSpec, N> {
717    fn cached_storage_settings(&self) -> reth_db_api::models::StorageSettings {
718        reth_db_api::models::StorageSettings::default()
719    }
720
721    fn set_storage_settings_cache(&self, _settings: reth_db_api::models::StorageSettings) {}
722}
reth_storage_api/noop.rs

reth_storage_api/
noop.rs
