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

fix: use pending state if available (#11391)

Browse Source
This commit is contained in:
Matthias Seitz
2024-10-01 20:34:14 +02:00
committed by GitHub
parent b722272c49
commit 2d221dbf49
1 changed files with 9 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
crates/storage/provider/src/providers/blockchain_provider.rs
View File

@ -233,9 +233,8 @@ impl<N: ProviderNodeTypes> BlockchainProvider2<N> {
/// This uses a given [`BlockState`] to initialize a state provider for that block. /// This uses a given [`BlockState`] to initialize a state provider for that block.
fn block_state_provider( fn block_state_provider(
&self, &self,
state: impl AsRef<BlockState>, state: &BlockState,
) -> ProviderResult<MemoryOverlayStateProvider> { ) -> ProviderResult<MemoryOverlayStateProvider> {
let state = state.as_ref();
let anchor_hash = state.anchor().hash; let anchor_hash = state.anchor().hash;
let latest_historical = self.database.history_by_block_hash(anchor_hash)?; let latest_historical = self.database.history_by_block_hash(anchor_hash)?;
Ok(self.canonical_in_memory_state.state_provider_from_state(state, latest_historical)) Ok(self.canonical_in_memory_state.state_provider_from_state(state, latest_historical))
@ -1077,7 +1076,7 @@ impl<N: ProviderNodeTypes> StateProviderFactory for BlockchainProvider2<N> {
// use latest state provider if the head state exists // use latest state provider if the head state exists
if let Some(state) = self.canonical_in_memory_state.head_state() { if let Some(state) = self.canonical_in_memory_state.head_state() {
trace!(target: "providers::blockchain", "Using head state for latest state provider"); trace!(target: "providers::blockchain", "Using head state for latest state provider");
Ok(self.block_state_provider(state)?.boxed()) Ok(self.block_state_provider(&state)?.boxed())
} else { } else {
trace!(target: "providers::blockchain", "Using database state for latest state provider"); trace!(target: "providers::blockchain", "Using database state for latest state provider");
self.database.latest() self.database.latest()
@ -1103,7 +1102,7 @@ impl<N: ProviderNodeTypes> StateProviderFactory for BlockchainProvider2<N> {
Ok(state) Ok(state)
} else if let Some(state) = self.canonical_in_memory_state.state_by_hash(block_hash) { } else if let Some(state) = self.canonical_in_memory_state.state_by_hash(block_hash) {
// ... or this could be tracked by the in memory state // ... or this could be tracked by the in memory state
let state_provider = self.block_state_provider(state)?; let state_provider = self.block_state_provider(&state)?;
Ok(Box::new(state_provider)) Ok(Box::new(state_provider))
} else { } else {
// if we couldn't find it anywhere, then we should return an error // if we couldn't find it anywhere, then we should return an error
@ -1132,12 +1131,9 @@ impl<N: ProviderNodeTypes> StateProviderFactory for BlockchainProvider2<N> {
fn pending(&self) -> ProviderResult<StateProviderBox> { fn pending(&self) -> ProviderResult<StateProviderBox> {
trace!(target: "providers::blockchain", "Getting provider for pending state"); trace!(target: "providers::blockchain", "Getting provider for pending state");
if let Some(block) = self.canonical_in_memory_state.pending_block_num_hash() { if let Some(pending) = self.canonical_in_memory_state.pending_state() {
let historical = self.database.history_by_block_hash(block.hash)?; // we have a pending block
let pending_provider = return Ok(Box::new(self.block_state_provider(&pending)?));
self.canonical_in_memory_state.state_provider(block.hash, historical);
return Ok(Box::new(pending_provider));
} }
// fallback to latest state if the pending block is not available // fallback to latest state if the pending block is not available
@ -1145,13 +1141,9 @@ impl<N: ProviderNodeTypes> StateProviderFactory for BlockchainProvider2<N> {
} }
fn pending_state_by_hash(&self, block_hash: B256) -> ProviderResult<Option<StateProviderBox>> { fn pending_state_by_hash(&self, block_hash: B256) -> ProviderResult<Option<StateProviderBox>> {
let historical = self.database.history_by_block_hash(block_hash)?; if let Some(pending) = self.canonical_in_memory_state.pending_state() {
if let Some(block) = self.canonical_in_memory_state.pending_block_num_hash() { if pending.hash() == block_hash {
if block.hash == block_hash { return Ok(Some(Box::new(self.block_state_provider(&pending)?)));
let pending_provider =
self.canonical_in_memory_state.state_provider(block_hash, historical);
return Ok(Some(Box::new(pending_provider)))
} }
} }
Ok(None) Ok(None)