jleony/nanoreth
1
0
Fork 0
mirror of https://github.com/hl-archive-node/nanoreth.git synced 2025-12-06 10:59:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: replace generic state provider with boxed trait (#9780)

Browse Source
This commit is contained in:
Federico Gimenez
2024-07-24 21:02:37 +02:00
committed by GitHub
parent 42a92eef07
commit bd7004a06a
2 changed files with 11 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
crates/engine/tree/src/tree/memory_overlay.rs
View File

@ -8,19 +8,18 @@ use reth_trie::{updates::TrieUpdates, AccountProof, HashedPostState};
/// A state provider that stores references to in-memory blocks along with their state as well as /// A state provider that stores references to in-memory blocks along with their state as well as
/// the historical state provider for fallback lookups. /// the historical state provider for fallback lookups.
#[derive(Debug)] pub struct MemoryOverlayStateProvider {
pub struct MemoryOverlayStateProvider<H> {
/// The collection of executed parent blocks. /// The collection of executed parent blocks.
in_memory: Vec<ExecutedBlock>, in_memory: Vec<ExecutedBlock>,
/// The collection of hashed state from in-memory blocks. /// The collection of hashed state from in-memory blocks.
hashed_post_state: HashedPostState, hashed_post_state: HashedPostState,
/// Historical state provider for state lookups that are not found in in-memory blocks. /// Historical state provider for state lookups that are not found in in-memory blocks.
historical: H, historical: Box<dyn StateProvider>,
} }
impl<H> MemoryOverlayStateProvider<H> { impl MemoryOverlayStateProvider {
/// Create new memory overlay state provider. /// Create new memory overlay state provider.
pub fn new(in_memory: Vec<ExecutedBlock>, historical: H) -> Self { pub fn new(in_memory: Vec<ExecutedBlock>, historical: Box<dyn StateProvider>) -> Self {
let mut hashed_post_state = HashedPostState::default(); let mut hashed_post_state = HashedPostState::default();
for block in &in_memory { for block in &in_memory {
hashed_post_state.extend(block.hashed_state.as_ref().clone()); hashed_post_state.extend(block.hashed_state.as_ref().clone());
@ -29,10 +28,7 @@ impl<H> MemoryOverlayStateProvider<H> {
} }
} }
impl<H> BlockHashReader for MemoryOverlayStateProvider<H> impl BlockHashReader for MemoryOverlayStateProvider {
where
H: BlockHashReader,
{
fn block_hash(&self, number: BlockNumber) -> ProviderResult<Option<B256>> { fn block_hash(&self, number: BlockNumber) -> ProviderResult<Option<B256>> {
for block in self.in_memory.iter().rev() { for block in self.in_memory.iter().rev() {
if block.block.number == number { if block.block.number == number {
@ -65,10 +61,7 @@ where
} }
} }
impl<H> AccountReader for MemoryOverlayStateProvider<H> impl AccountReader for MemoryOverlayStateProvider {
where
H: AccountReader + Send,
{
fn basic_account(&self, address: Address) -> ProviderResult<Option<Account>> { fn basic_account(&self, address: Address) -> ProviderResult<Option<Account>> {
for block in self.in_memory.iter().rev() { for block in self.in_memory.iter().rev() {
if let Some(account) = block.execution_output.account(&address) { if let Some(account) = block.execution_output.account(&address) {
@ -80,10 +73,7 @@ where
} }
} }
impl<H> StateRootProvider for MemoryOverlayStateProvider<H> impl StateRootProvider for MemoryOverlayStateProvider {
where
H: StateRootProvider + Send,
{
// TODO: Currently this does not reuse available in-memory trie nodes. // TODO: Currently this does not reuse available in-memory trie nodes.
fn hashed_state_root(&self, hashed_state: &HashedPostState) -> ProviderResult<B256> { fn hashed_state_root(&self, hashed_state: &HashedPostState) -> ProviderResult<B256> {
let mut state = self.hashed_post_state.clone(); let mut state = self.hashed_post_state.clone();
@ -102,10 +92,7 @@ where
} }
} }
impl<H> StateProofProvider for MemoryOverlayStateProvider<H> impl StateProofProvider for MemoryOverlayStateProvider {
where
H: StateProofProvider + Send,
{
// TODO: Currently this does not reuse available in-memory trie nodes. // TODO: Currently this does not reuse available in-memory trie nodes.
fn hashed_proof( fn hashed_proof(
&self, &self,
@ -119,10 +106,7 @@ where
} }
} }
impl<H> StateProvider for MemoryOverlayStateProvider<H> impl StateProvider for MemoryOverlayStateProvider {
where
H: StateProvider + Send,
{
fn storage( fn storage(
&self, &self,
address: Address, address: Address,

8
crates/engine/tree/src/tree/mod.rs
View File

@ -26,8 +26,7 @@ use reth_primitives::{
SealedBlockWithSenders, SealedHeader, B256, U256, SealedBlockWithSenders, SealedHeader, B256, U256,
}; };
use reth_provider::{ use reth_provider::{
BlockReader, ExecutionOutcome, ProviderError, StateProvider, StateProviderFactory, BlockReader, ExecutionOutcome, ProviderError, StateProviderFactory, StateRootProvider,
StateRootProvider,
}; };
use reth_revm::database::StateProviderDatabase; use reth_revm::database::StateProviderDatabase;
use reth_rpc_types::{ use reth_rpc_types::{
@ -676,10 +675,7 @@ where
/// This merges the state of all blocks that are part of the chain that the requested block is /// This merges the state of all blocks that are part of the chain that the requested block is
/// the head of. This includes all blocks that connect back to the canonical block on disk. /// the head of. This includes all blocks that connect back to the canonical block on disk.
// TODO: return error if the chain has gaps // TODO: return error if the chain has gaps
fn state_provider( fn state_provider(&self, hash: B256) -> ProviderResult<MemoryOverlayStateProvider> {
&self,
hash: B256,
) -> ProviderResult<MemoryOverlayStateProvider<Box<dyn StateProvider>>> {
let mut in_memory = Vec::new(); let mut in_memory = Vec::new();
let mut parent_hash = hash; let mut parent_hash = hash;
while let Some(executed) = self.state.tree_state.blocks_by_hash.get(&parent_hash) { while let Some(executed) = self.state.tree_state.blocks_by_hash.get(&parent_hash) {