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

feat: add SealedBlock in reth-primitives-traits (#13735)

Browse Source
This commit is contained in:
Matthias Seitz
2025-01-15 02:12:43 +01:00
committed by GitHub
parent 1267718c7e
commit 83b2fb9b41
171 changed files with 3231 additions and 2866 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -27,8 +27,8 @@ use reth_evm::{env::EvmEnv, ConfigureEvmEnv};
use reth_execution_types::ExecutionOutcome;
use reth_node_types::{BlockTy, HeaderTy, NodeTypesWithDB, ReceiptTy, TxTy};
use reth_primitives::{
Account, Block, BlockWithSenders, EthPrimitives, NodePrimitives, Receipt, SealedBlock,
SealedBlockFor, SealedBlockWithSenders, SealedHeader, StorageEntry, TransactionSigned,
Account, Block, EthPrimitives, NodePrimitives, Receipt, RecoveredBlock, SealedBlock,
SealedHeader, StorageEntry, TransactionSigned,
};
use reth_primitives_traits::BlockBody;
use reth_prune_types::{PruneCheckpoint, PruneSegment};
@ -296,19 +296,17 @@ impl<N: ProviderNodeTypes> BlockReader for BlockchainProvider<N> {
self.consistent_provider()?.block(id)
}
fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
fn pending_block(&self) -> ProviderResult<Option<SealedBlock<Self::Block>>> {
Ok(self.canonical_in_memory_state.pending_block())
}
fn pending_block_with_senders(
&self,
) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
Ok(self.canonical_in_memory_state.pending_block_with_senders())
fn pending_block_with_senders(&self) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
Ok(self.canonical_in_memory_state.pending_recovered_block())
}
fn pending_block_and_receipts(
&self,
) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Self::Receipt>)>> {
) -> ProviderResult<Option<(SealedBlock<Self::Block>, Vec<Self::Receipt>)>> {
Ok(self.canonical_in_memory_state.pending_block_and_receipts())
}
@ -322,7 +320,7 @@ impl<N: ProviderNodeTypes> BlockReader for BlockchainProvider<N> {
&self,
id: BlockHashOrNumber,
transaction_kind: TransactionVariant,
) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
self.consistent_provider()?.block_with_senders(id, transaction_kind)
}
@ -330,7 +328,7 @@ impl<N: ProviderNodeTypes> BlockReader for BlockchainProvider<N> {
&self,
id: BlockHashOrNumber,
transaction_kind: TransactionVariant,
) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
self.consistent_provider()?.sealed_block_with_senders(id, transaction_kind)
}
@ -341,14 +339,14 @@ impl<N: ProviderNodeTypes> BlockReader for BlockchainProvider<N> {
fn block_with_senders_range(
&self,
range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
self.consistent_provider()?.block_with_senders_range(range)
}
fn sealed_block_with_senders_range(
&self,
range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
self.consistent_provider()?.sealed_block_with_senders_range(range)
}
}
@ -794,7 +792,7 @@ mod tests {
use reth_db_api::{cursor::DbCursorRO, transaction::DbTx};
use reth_errors::ProviderError;
use reth_execution_types::{Chain, ExecutionOutcome};
use reth_primitives::{BlockExt, EthPrimitives, Receipt, SealedBlock, StaticFileSegment};
use reth_primitives::{EthPrimitives, Receipt, SealedBlock, StaticFileSegment};
use reth_primitives_traits::{BlockBody, SignedTransaction};
use reth_storage_api::{
BlockBodyIndicesProvider, BlockHashReader, BlockIdReader, BlockNumReader, BlockReader,
@ -907,7 +905,7 @@ mod tests {
}
provider_rw.insert_historical_block(
block.clone().seal_with_senders().expect("failed to seal block with senders"),
block.clone().try_recover().expect("failed to seal block with senders"),
)?;
}
@ -1027,7 +1025,7 @@ mod tests {
let provider_rw = factory.provider_rw()?;
for block in database_blocks {
provider_rw.insert_historical_block(
block.clone().seal_with_senders().expect("failed to seal block with senders"),
block.clone().try_recover().expect("failed to seal block with senders"),
)?;
}
provider_rw.commit()?;
@ -1069,21 +1067,21 @@ mod tests {
// Now the block should be found in memory
assert_eq!(
provider.find_block_by_hash(first_in_mem_block.hash(), BlockSource::Any)?,
Some(first_in_mem_block.clone().into())
Some(first_in_mem_block.clone().into_block())
);
assert_eq!(
provider.find_block_by_hash(first_in_mem_block.hash(), BlockSource::Canonical)?,
Some(first_in_mem_block.clone().into())
Some(first_in_mem_block.clone().into_block())
);
// Find the first block in database by hash
assert_eq!(
provider.find_block_by_hash(first_db_block.hash(), BlockSource::Any)?,
Some(first_db_block.clone().into())
Some(first_db_block.clone().into_block())
);
assert_eq!(
provider.find_block_by_hash(first_db_block.hash(), BlockSource::Canonical)?,
Some(first_db_block.clone().into())
Some(first_db_block.clone().into_block())
);
// No pending block in database
@ -1101,7 +1099,7 @@ mod tests {
// Now the last block should be found in memory
assert_eq!(
provider.find_block_by_hash(last_in_mem_block.hash(), BlockSource::Pending)?,
Some(last_in_mem_block.clone().into())
Some(last_in_mem_block.clone().into_block())
);
Ok(())
@ -1125,7 +1123,7 @@ mod tests {
let provider_rw = factory.provider_rw()?;
for block in database_blocks {
provider_rw.insert_historical_block(
block.clone().seal_with_senders().expect("failed to seal block with senders"),
block.clone().try_recover().expect("failed to seal block with senders"),
)?;
}
provider_rw.commit()?;
@ -1159,21 +1157,21 @@ mod tests {
// First in memory block should be found
assert_eq!(
provider.block(BlockHashOrNumber::Hash(first_in_mem_block.hash()))?,
Some(first_in_mem_block.clone().into())
Some(first_in_mem_block.clone().into_block())
);
assert_eq!(
provider.block(BlockHashOrNumber::Number(first_in_mem_block.number))?,
Some(first_in_mem_block.clone().into())
Some(first_in_mem_block.clone().into_block())
);
// First database block should be found
assert_eq!(
provider.block(BlockHashOrNumber::Hash(first_db_block.hash()))?,
Some(first_db_block.clone().into())
Some(first_db_block.clone().into_block())
);
assert_eq!(
provider.block(BlockHashOrNumber::Number(first_db_block.number))?,
Some(first_db_block.clone().into())
Some(first_db_block.clone().into_block())
);
Ok(())
@ -1211,7 +1209,7 @@ mod tests {
assert_eq!(
provider.pending_block_with_senders()?,
Some(reth_primitives::SealedBlockWithSenders::new_unchecked(
Some(reth_primitives::RecoveredBlock::new_sealed(
block.clone(),
block.senders().unwrap()
))
@ -1508,19 +1506,22 @@ mod tests {
assert_eq!(
provider.block_by_id(block_number.into()).unwrap(),
Some(database_block.clone().unseal())
Some(database_block.clone().into_block())
);
assert_eq!(
provider.block_by_id(block_hash.into()).unwrap(),
Some(database_block.into_block())
);
assert_eq!(provider.block_by_id(block_hash.into()).unwrap(), Some(database_block.unseal()));
let block_number = in_memory_block.number;
let block_hash = in_memory_block.hash();
assert_eq!(
provider.block_by_id(block_number.into()).unwrap(),
Some(in_memory_block.clone().unseal())
Some(in_memory_block.clone().into_block())
);
assert_eq!(
provider.block_by_id(block_hash.into()).unwrap(),
Some(in_memory_block.unseal())
Some(in_memory_block.into_block())
);
Ok(())
@ -1806,7 +1807,7 @@ mod tests {
provider_rw.append_blocks_with_state(
database_blocks
.into_iter()
.map(|b| b.seal_with_senders().expect("failed to seal block with senders"))
.map(|b| b.try_recover().expect("failed to seal block with senders"))
.collect(),
&ExecutionOutcome {
bundle: BundleState::new(
@ -2326,14 +2327,12 @@ mod tests {
test_by_block_range!([
(headers_range, |block: &SealedBlock| block.header().clone()),
(sealed_headers_range, |block: &SealedBlock| block.clone_sealed_header()),
(block_range, |block: &SealedBlock| block.clone().unseal()),
(block_with_senders_range, |block: &SealedBlock| block
.clone()
.unseal::<reth_primitives::Block>()
.with_senders_unchecked(vec![])),
(block_range, |block: &SealedBlock| block.clone().into_block()),
(block_with_senders_range, |block: &SealedBlock| block.clone().try_recover().unwrap()),
(sealed_block_with_senders_range, |block: &SealedBlock| block
.clone()
.with_senders_unchecked(vec![])),
.try_recover()
.unwrap()),
(transactions_by_block_range, |block: &SealedBlock| block.body().transactions.clone()),
]);
@ -2494,7 +2493,7 @@ mod tests {
block,
|block: &SealedBlock, _: TxNumber, _: B256, _: &Vec<Vec<Receipt>>| (
BlockHashOrNumber::Hash(block.hash()),
Some(block.clone().unseal())
Some(block.clone().into_block())
),
BlockHashOrNumber::Hash(B256::random())
),
@ -2503,7 +2502,7 @@ mod tests {
block,
|block: &SealedBlock, _: TxNumber, _: B256, _: &Vec<Vec<Receipt>>| (
BlockHashOrNumber::Number(block.number),
Some(block.clone().unseal())
Some(block.clone().into_block())
),
BlockHashOrNumber::Number(u64::MAX)
),
@ -2524,7 +2523,7 @@ mod tests {
block_with_senders,
|block: &SealedBlock, _: TxNumber, _: B256, _: &Vec<Vec<Receipt>>| (
(BlockHashOrNumber::Number(block.number), TransactionVariant::WithHash),
block.clone().unseal::<reth_primitives::Block>().with_recovered_senders()
block.clone().try_recover().ok()
),
(BlockHashOrNumber::Number(u64::MAX), TransactionVariant::WithHash)
),
@ -2533,7 +2532,7 @@ mod tests {
block_with_senders,
|block: &SealedBlock, _: TxNumber, _: B256, _: &Vec<Vec<Receipt>>| (
(BlockHashOrNumber::Hash(block.hash()), TransactionVariant::WithHash),
block.clone().unseal::<reth_primitives::Block>().with_recovered_senders()
block.clone().try_recover().ok()
),
(BlockHashOrNumber::Hash(B256::random()), TransactionVariant::WithHash)
),
@ -2542,14 +2541,7 @@ mod tests {
sealed_block_with_senders,
|block: &SealedBlock, _: TxNumber, _: B256, _: &Vec<Vec<Receipt>>| (
(BlockHashOrNumber::Number(block.number), TransactionVariant::WithHash),
Some(
block
.clone()
.unseal::<reth_primitives::Block>()
.with_recovered_senders()
.unwrap()
.seal_unchecked(block.hash())
)
block.clone().try_recover().ok()
),
(BlockHashOrNumber::Number(u64::MAX), TransactionVariant::WithHash)
),
@ -2558,14 +2550,7 @@ mod tests {
sealed_block_with_senders,
|block: &SealedBlock, _: TxNumber, _: B256, _: &Vec<Vec<Receipt>>| (
(BlockHashOrNumber::Hash(block.hash()), TransactionVariant::WithHash),
Some(
block
.clone()
.unseal::<reth_primitives::Block>()
.with_recovered_senders()
.unwrap()
.seal_unchecked(block.hash())
)
block.clone().try_recover().ok()
),
(BlockHashOrNumber::Hash(B256::random()), TransactionVariant::WithHash)
),

68
crates/storage/provider/src/providers/consistent.rs
View File

@ -21,9 +21,7 @@ use reth_db::models::BlockNumberAddress;
use reth_db_api::models::{AccountBeforeTx, StoredBlockBodyIndices};
use reth_execution_types::{BundleStateInit, ExecutionOutcome, RevertsInit};
use reth_node_types::{BlockTy, HeaderTy, ReceiptTy, TxTy};
use reth_primitives::{
Account, BlockWithSenders, SealedBlockFor, SealedBlockWithSenders, SealedHeader, StorageEntry,
};
use reth_primitives::{Account, RecoveredBlock, SealedBlock, SealedHeader, StorageEntry};
use reth_primitives_traits::BlockBody;
use reth_prune_types::{PruneCheckpoint, PruneSegment};
use reth_stages_types::{StageCheckpoint, StageId};
@ -804,11 +802,11 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
self.get_in_memory_or_storage_by_block(
hash.into(),
|db_provider| db_provider.find_block_by_hash(hash, source),
|block_state| Ok(Some(block_state.block_ref().block().clone().unseal())),
|block_state| Ok(Some(block_state.block_ref().block().clone_block())),
)
}
BlockSource::Pending => {
Ok(self.canonical_in_memory_state.pending_block().map(|block| block.unseal()))
Ok(self.canonical_in_memory_state.pending_block().map(|block| block.into_block()))
}
}
}
@ -817,23 +815,21 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
self.get_in_memory_or_storage_by_block(
id,
|db_provider| db_provider.block(id),
|block_state| Ok(Some(block_state.block_ref().block().clone().unseal())),
|block_state| Ok(Some(block_state.block_ref().block().clone_block())),
)
}
fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
fn pending_block(&self) -> ProviderResult<Option<SealedBlock<Self::Block>>> {
Ok(self.canonical_in_memory_state.pending_block())
}
fn pending_block_with_senders(
&self,
) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
Ok(self.canonical_in_memory_state.pending_block_with_senders())
fn pending_block_with_senders(&self) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
Ok(self.canonical_in_memory_state.pending_recovered_block())
}
fn pending_block_and_receipts(
&self,
) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Self::Receipt>)>> {
) -> ProviderResult<Option<(SealedBlock<Self::Block>, Vec<Self::Receipt>)>> {
Ok(self.canonical_in_memory_state.pending_block_and_receipts())
}
@ -847,11 +843,11 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
&self,
id: BlockHashOrNumber,
transaction_kind: TransactionVariant,
) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
self.get_in_memory_or_storage_by_block(
id,
|db_provider| db_provider.block_with_senders(id, transaction_kind),
|block_state| Ok(Some(block_state.block_with_senders())),
|block_state| Ok(Some(block_state.clone_recovered_block())),
)
}
@ -859,11 +855,11 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
&self,
id: BlockHashOrNumber,
transaction_kind: TransactionVariant,
) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
self.get_in_memory_or_storage_by_block(
id,
|db_provider| db_provider.sealed_block_with_senders(id, transaction_kind),
|block_state| Ok(Some(block_state.sealed_block_with_senders())),
|block_state| Ok(Some(block_state.clone_recovered_block())),
)
}
@ -871,7 +867,7 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
self.get_in_memory_or_storage_by_block_range_while(
range,
|db_provider, range, _| db_provider.block_range(range),
|block_state, _| Some(block_state.block_ref().block().clone().unseal()),
|block_state, _| Some(block_state.block_ref().block().clone_block()),
|_| true,
)
}
@ -879,11 +875,11 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
fn block_with_senders_range(
&self,
range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
self.get_in_memory_or_storage_by_block_range_while(
range,
|db_provider, range, _| db_provider.block_with_senders_range(range),
|block_state, _| Some(block_state.block_with_senders()),
|block_state, _| Some(block_state.clone_recovered_block()),
|_| true,
)
}
@ -891,11 +887,11 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
fn sealed_block_with_senders_range(
&self,
range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
self.get_in_memory_or_storage_by_block_range_while(
range,
|db_provider, range, _| db_provider.sealed_block_with_senders_range(range),
|block_state, _| Some(block_state.sealed_block_with_senders()),
|block_state, _| Some(block_state.clone_recovered_block()),
|_| true,
)
}
@ -1271,11 +1267,11 @@ impl<N: ProviderNodeTypes> BlockReaderIdExt for ConsistentProvider<N> {
BlockNumberOrTag::Safe => Ok(self.canonical_in_memory_state.get_safe_header()),
BlockNumberOrTag::Earliest => self
.header_by_number(0)?
.map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal(h)))),
.map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal_slow(h)))),
BlockNumberOrTag::Pending => Ok(self.canonical_in_memory_state.pending_sealed_header()),
BlockNumberOrTag::Number(num) => self
.header_by_number(num)?
.map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal(h)))),
.map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal_slow(h)))),
}
}
@ -1285,7 +1281,7 @@ impl<N: ProviderNodeTypes> BlockReaderIdExt for ConsistentProvider<N> {
) -> ProviderResult<Option<SealedHeader<HeaderTy<N>>>> {
Ok(match id {
BlockId::Number(num) => self.sealed_header_by_number_or_tag(num)?,
BlockId::Hash(hash) => self.header(&hash.block_hash)?.map(SealedHeader::seal),
BlockId::Hash(hash) => self.header(&hash.block_hash)?.map(SealedHeader::seal_slow),
})
}
@ -1518,7 +1514,7 @@ mod tests {
let provider_rw = factory.provider_rw()?;
for block in database_blocks {
provider_rw.insert_historical_block(
block.clone().seal_with_senders().expect("failed to seal block with senders"),
block.clone().try_recover().expect("failed to seal block with senders"),
)?;
}
provider_rw.commit()?;
@ -1567,23 +1563,23 @@ mod tests {
// Now the block should be found in memory
assert_eq!(
consistent_provider.find_block_by_hash(first_in_mem_block.hash(), BlockSource::Any)?,
Some(first_in_mem_block.clone().into())
Some(first_in_mem_block.clone().into_block())
);
assert_eq!(
consistent_provider
.find_block_by_hash(first_in_mem_block.hash(), BlockSource::Canonical)?,
Some(first_in_mem_block.clone().into())
Some(first_in_mem_block.clone().into_block())
);
// Find the first block in database by hash
assert_eq!(
consistent_provider.find_block_by_hash(first_db_block.hash(), BlockSource::Any)?,
Some(first_db_block.clone().into())
Some(first_db_block.clone().into_block())
);
assert_eq!(
consistent_provider
.find_block_by_hash(first_db_block.hash(), BlockSource::Canonical)?,
Some(first_db_block.clone().into())
Some(first_db_block.clone().into_block())
);
// No pending block in database
@ -1605,7 +1601,7 @@ mod tests {
assert_eq!(
consistent_provider
.find_block_by_hash(last_in_mem_block.hash(), BlockSource::Pending)?,
Some(last_in_mem_block.clone().into())
Some(last_in_mem_block.clone_block())
);
Ok(())
@ -1629,7 +1625,7 @@ mod tests {
let provider_rw = factory.provider_rw()?;
for block in database_blocks {
provider_rw.insert_historical_block(
block.clone().seal_with_senders().expect("failed to seal block with senders"),
block.clone().try_recover().expect("failed to seal block with senders"),
)?;
}
provider_rw.commit()?;
@ -1672,21 +1668,21 @@ mod tests {
// First in memory block should be found
assert_eq!(
consistent_provider.block(BlockHashOrNumber::Hash(first_in_mem_block.hash()))?,
Some(first_in_mem_block.clone().into())
Some(first_in_mem_block.clone().into_block())
);
assert_eq!(
consistent_provider.block(BlockHashOrNumber::Number(first_in_mem_block.number))?,
Some(first_in_mem_block.clone().into())
Some(first_in_mem_block.clone().into_block())
);
// First database block should be found
assert_eq!(
consistent_provider.block(BlockHashOrNumber::Hash(first_db_block.hash()))?,
Some(first_db_block.clone().into())
Some(first_db_block.clone().into_block())
);
assert_eq!(
consistent_provider.block(BlockHashOrNumber::Number(first_db_block.number))?,
Some(first_db_block.clone().into())
Some(first_db_block.clone().into_block())
);
Ok(())
@ -1728,7 +1724,7 @@ mod tests {
provider_rw.append_blocks_with_state(
database_blocks
.into_iter()
.map(|b| b.seal_with_senders().expect("failed to seal block with senders"))
.map(|b| b.try_recover().expect("failed to seal block with senders"))
.collect(),
&ExecutionOutcome {
bundle: BundleState::new(

38
crates/storage/provider/src/providers/database/mod.rs
View File

@ -16,9 +16,7 @@ use reth_db::{init_db, mdbx::DatabaseArguments, DatabaseEnv};
use reth_db_api::{database::Database, models::StoredBlockBodyIndices};
use reth_errors::{RethError, RethResult};
use reth_node_types::{BlockTy, HeaderTy, NodeTypesWithDB, ReceiptTy, TxTy};
use reth_primitives::{
BlockWithSenders, SealedBlockFor, SealedBlockWithSenders, SealedHeader, StaticFileSegment,
};
use reth_primitives::{RecoveredBlock, SealedBlock, SealedHeader, StaticFileSegment};
use reth_prune_types::{PruneCheckpoint, PruneModes, PruneSegment};
use reth_stages_types::{StageCheckpoint, StageId};
use reth_storage_api::{
@ -382,19 +380,17 @@ impl<N: ProviderNodeTypes> BlockReader for ProviderFactory<N> {
self.provider()?.block(id)
}
fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
fn pending_block(&self) -> ProviderResult<Option<SealedBlock<Self::Block>>> {
self.provider()?.pending_block()
}
fn pending_block_with_senders(
&self,
) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
fn pending_block_with_senders(&self) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
self.provider()?.pending_block_with_senders()
}
fn pending_block_and_receipts(
&self,
) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Self::Receipt>)>> {
) -> ProviderResult<Option<(SealedBlock<Self::Block>, Vec<Self::Receipt>)>> {
self.provider()?.pending_block_and_receipts()
}
@ -402,7 +398,7 @@ impl<N: ProviderNodeTypes> BlockReader for ProviderFactory<N> {
&self,
id: BlockHashOrNumber,
transaction_kind: TransactionVariant,
) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
self.provider()?.block_with_senders(id, transaction_kind)
}
@ -410,7 +406,7 @@ impl<N: ProviderNodeTypes> BlockReader for ProviderFactory<N> {
&self,
id: BlockHashOrNumber,
transaction_kind: TransactionVariant,
) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
self.provider()?.sealed_block_with_senders(id, transaction_kind)
}
@ -421,14 +417,14 @@ impl<N: ProviderNodeTypes> BlockReader for ProviderFactory<N> {
fn block_with_senders_range(
&self,
range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
self.provider()?.block_with_senders_range(range)
}
fn sealed_block_with_senders_range(
&self,
range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
self.provider()?.sealed_block_with_senders_range(range)
}
}
@ -703,10 +699,8 @@ mod tests {
{
let provider = factory.provider_rw().unwrap();
assert_matches!(
provider.insert_block(
block.clone().try_seal_with_senders().unwrap(),
StorageLocation::Database
),
provider
.insert_block(block.clone().try_recover().unwrap(), StorageLocation::Database),
Ok(_)
);
assert_matches!(
@ -727,10 +721,8 @@ mod tests {
};
let provider = factory.with_prune_modes(prune_modes).provider_rw().unwrap();
assert_matches!(
provider.insert_block(
block.clone().try_seal_with_senders().unwrap(),
StorageLocation::Database
),
provider
.insert_block(block.clone().try_recover().unwrap(), StorageLocation::Database),
Ok(_)
);
assert_matches!(provider.transaction_sender(0), Ok(None));
@ -751,10 +743,8 @@ mod tests {
let provider = factory.provider_rw().unwrap();
assert_matches!(
provider.insert_block(
block.clone().try_seal_with_senders().unwrap(),
StorageLocation::Database
),
provider
.insert_block(block.clone().try_recover().unwrap(), StorageLocation::Database),
Ok(_)
);

51
crates/storage/provider/src/providers/database/provider.rs
View File

@ -47,8 +47,8 @@ use reth_execution_types::{Chain, ExecutionOutcome};
use reth_network_p2p::headers::downloader::SyncTarget;
use reth_node_types::{BlockTy, BodyTy, HeaderTy, NodeTypes, ReceiptTy, TxTy};
use reth_primitives::{
Account, BlockExt, BlockWithSenders, Bytecode, GotExpected, NodePrimitives, SealedBlock,
SealedBlockFor, SealedBlockWithSenders, SealedHeader, StaticFileSegment, StorageEntry,
Account, Bytecode, GotExpected, NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader,
StaticFileSegment, StorageEntry,
};
use reth_primitives_traits::{Block as _, BlockBody as _, SignedTransaction};
use reth_prune_types::{PruneCheckpoint, PruneModes, PruneSegment};
@ -424,14 +424,14 @@ impl<
/// Inserts an historical block. **Used for setting up test environments**
pub fn insert_historical_block(
&self,
block: SealedBlockWithSenders<<Self as BlockWriter>::Block>,
block: RecoveredBlock<<Self as BlockWriter>::Block>,
) -> ProviderResult<StoredBlockBodyIndices> {
let ttd = if block.number() == 0 {
block.difficulty()
block.header().difficulty()
} else {
let parent_block_number = block.number() - 1;
let parent_ttd = self.header_td_by_number(parent_block_number)?.unwrap_or_default();
parent_ttd + block.difficulty()
parent_ttd + block.header().difficulty()
};
let mut writer = self.static_file_provider.latest_writer(StaticFileSegment::Headers)?;
@ -440,7 +440,7 @@ impl<
let segment_header = writer.user_header();
if segment_header.block_end().is_none() && segment_header.expected_block_start() == 0 {
for block_number in 0..block.number() {
let mut prev = block.clone_sealed_header().unseal();
let mut prev = block.clone_header();
prev.number = block_number;
writer.append_header(&prev, U256::ZERO, &B256::ZERO)?;
}
@ -1197,19 +1197,17 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
Ok(None)
}
fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
fn pending_block(&self) -> ProviderResult<Option<SealedBlock<Self::Block>>> {
Ok(None)
}
fn pending_block_with_senders(
&self,
) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
fn pending_block_with_senders(&self) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
Ok(None)
}
fn pending_block_and_receipts(
&self,
) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Self::Receipt>)>> {
) -> ProviderResult<Option<(SealedBlock<Self::Block>, Vec<Self::Receipt>)>> {
Ok(None)
}
@ -1225,7 +1223,7 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
&self,
id: BlockHashOrNumber,
transaction_kind: TransactionVariant,
) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
self.block_with_senders(
id,
transaction_kind,
@ -1246,13 +1244,13 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
&self,
id: BlockHashOrNumber,
transaction_kind: TransactionVariant,
) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
self.block_with_senders(
id,
transaction_kind,
|block_number| self.sealed_header(block_number),
|header, body, senders| {
SealedBlock::new(header, body)
Self::Block::new_sealed(header, body)
// Note: we're using unchecked here because we know the block contains valid txs
// wrt to its height and can ignore the s value check so pre
// EIP-2 txs are allowed
@ -1274,7 +1272,7 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
fn block_with_senders_range(
&self,
range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
self.block_with_senders_range(
range,
|range| self.headers_range(range),
@ -1289,13 +1287,14 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
fn sealed_block_with_senders_range(
&self,
range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
self.block_with_senders_range(
range,
|range| self.sealed_headers_range(range),
|header, body, senders| {
SealedBlockWithSenders::new(SealedBlock::new(header, body), senders)
.ok_or(ProviderError::SenderRecoveryError)
Self::Block::new_sealed(header, body)
.try_with_senders(senders)
.map_err(|_| ProviderError::SenderRecoveryError)
},
)
}
@ -2749,7 +2748,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
/// [`TransactionHashNumbers`](tables::TransactionHashNumbers).
fn insert_block(
&self,
block: SealedBlockWithSenders<Self::Block>,
block: RecoveredBlock<Self::Block>,
write_to: StorageLocation,
) -> ProviderResult<StoredBlockBodyIndices> {
let block_number = block.number();
@ -2758,12 +2757,12 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
// total difficulty
let ttd = if block_number == 0 {
block.difficulty()
block.header().difficulty()
} else {
let parent_block_number = block_number - 1;
let parent_ttd = self.header_td_by_number(parent_block_number)?.unwrap_or_default();
durations_recorder.record_relative(metrics::Action::GetParentTD);
parent_ttd + block.difficulty()
parent_ttd + block.header().difficulty()
};
if write_to.database() {
@ -2796,12 +2795,10 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
durations_recorder.record_relative(metrics::Action::GetNextTxNum);
let first_tx_num = next_tx_num;
let tx_count = block.block.body().transactions().len() as u64;
let tx_count = block.body().transaction_count() as u64;
// Ensures we have all the senders for the block's transactions.
for (transaction, sender) in
block.block.body().transactions().iter().zip(block.senders_iter())
{
for (transaction, sender) in block.body().transactions().iter().zip(block.senders_iter()) {
let hash = transaction.tx_hash();
if self.prune_modes.sender_recovery.as_ref().is_none_or(|m| !m.is_full()) {
@ -2814,7 +2811,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
next_tx_num += 1;
}
self.append_block_bodies(vec![(block_number, Some(block.block.into_body()))], write_to)?;
self.append_block_bodies(vec![(block_number, Some(block.into_body()))], write_to)?;
debug!(
target: "providers::db",
@ -2992,7 +2989,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
/// TODO(joshie): this fn should be moved to `UnifiedStorageWriter` eventually
fn append_blocks_with_state(
&self,
blocks: Vec<SealedBlockWithSenders<Self::Block>>,
blocks: Vec<RecoveredBlock<Self::Block>>,
execution_outcome: &ExecutionOutcome<Self::Receipt>,
hashed_state: HashedPostStateSorted,
trie_updates: TrieUpdates,

19
crates/storage/provider/src/providers/static_file/manager.rs
View File

@ -33,8 +33,7 @@ use reth_primitives::{
find_fixed_range, HighestStaticFiles, SegmentHeader, SegmentRangeInclusive,
DEFAULT_BLOCKS_PER_STATIC_FILE,
},
BlockWithSenders, Receipt, SealedBlockFor, SealedBlockWithSenders, SealedHeader,
StaticFileSegment, TransactionSigned,
Receipt, RecoveredBlock, SealedBlock, SealedHeader, StaticFileSegment, TransactionSigned,
};
use reth_primitives_traits::SignedTransaction;
use reth_stages_types::{PipelineTarget, StageId};
@ -1621,21 +1620,19 @@ impl<N: FullNodePrimitives<SignedTx: Value, Receipt: Value, BlockHeader: Value>>
Err(ProviderError::UnsupportedProvider)
}
fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
fn pending_block(&self) -> ProviderResult<Option<SealedBlock<Self::Block>>> {
// Required data not present in static_files
Err(ProviderError::UnsupportedProvider)
}
fn pending_block_with_senders(
&self,
) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
fn pending_block_with_senders(&self) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
// Required data not present in static_files
Err(ProviderError::UnsupportedProvider)
}
fn pending_block_and_receipts(
&self,
) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Self::Receipt>)>> {
) -> ProviderResult<Option<(SealedBlock<Self::Block>, Vec<Self::Receipt>)>> {
// Required data not present in static_files
Err(ProviderError::UnsupportedProvider)
}
@ -1644,7 +1641,7 @@ impl<N: FullNodePrimitives<SignedTx: Value, Receipt: Value, BlockHeader: Value>>
&self,
_id: BlockHashOrNumber,
_transaction_kind: TransactionVariant,
) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
// Required data not present in static_files
Err(ProviderError::UnsupportedProvider)
}
@ -1653,7 +1650,7 @@ impl<N: FullNodePrimitives<SignedTx: Value, Receipt: Value, BlockHeader: Value>>
&self,
_id: BlockHashOrNumber,
_transaction_kind: TransactionVariant,
) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
// Required data not present in static_files
Err(ProviderError::UnsupportedProvider)
}
@ -1666,14 +1663,14 @@ impl<N: FullNodePrimitives<SignedTx: Value, Receipt: Value, BlockHeader: Value>>
fn block_with_senders_range(
&self,
_range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
Err(ProviderError::UnsupportedProvider)
}
fn sealed_block_with_senders_range(
&self,
_range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
Err(ProviderError::UnsupportedProvider)
}
}

2
crates/storage/provider/src/providers/static_file/mod.rs
View File

@ -110,7 +110,7 @@ mod tests {
let hash = header.hash();
tx.put::<CanonicalHeaders>(header.number, hash).unwrap();
tx.put::<Headers>(header.number, header.clone().unseal()).unwrap();
tx.put::<Headers>(header.number, header.clone_header()).unwrap();
tx.put::<HeaderTerminalDifficulties>(header.number, td.into()).unwrap();
tx.put::<HeaderNumbers>(hash, header.number).unwrap();
}

68
crates/storage/provider/src/test_utils/blocks.rs
View File

@ -12,7 +12,7 @@ use reth_db::tables;
use reth_db_api::{database::Database, models::StoredBlockBodyIndices};
use reth_node_types::NodeTypes;
use reth_primitives::{
Account, BlockBody, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader, Transaction,
Account, BlockBody, Receipt, RecoveredBlock, SealedBlock, SealedHeader, Transaction,
TransactionSigned, TxType,
};
use reth_trie::root::{state_root_unhashed, storage_root_unhashed};
@ -64,7 +64,7 @@ pub fn assert_genesis_block<DB: Database, N: NodeTypes>(
}
pub(crate) static TEST_BLOCK: LazyLock<SealedBlock> = LazyLock::new(|| {
SealedBlock::new(
SealedBlock::from_sealed_parts(
SealedHeader::new(
Header {
parent_hash: hex!(
@ -127,7 +127,7 @@ pub struct BlockchainTestData {
/// Genesis
pub genesis: SealedBlock,
/// Blocks with its execution result
pub blocks: Vec<(SealedBlockWithSenders, ExecutionOutcome)>,
pub blocks: Vec<(RecoveredBlock<reth_primitives::Block>, ExecutionOutcome)>,
}
impl BlockchainTestData {
@ -163,7 +163,7 @@ impl Default for BlockchainTestData {
/// Genesis block
pub fn genesis() -> SealedBlock {
SealedBlock::new(
SealedBlock::from_sealed_parts(
SealedHeader::new(
Header { number: 0, difficulty: U256::from(1), ..Default::default() },
B256::ZERO,
@ -192,7 +192,7 @@ fn bundle_state_root(execution_outcome: &ExecutionOutcome) -> B256 {
}
/// Block one that points to genesis
fn block1(number: BlockNumber) -> (SealedBlockWithSenders, ExecutionOutcome) {
fn block1(number: BlockNumber) -> (RecoveredBlock<reth_primitives::Block>, ExecutionOutcome) {
// block changes
let account1: Address = [0x60; 20].into();
let account2: Address = [0x61; 20].into();
@ -232,18 +232,14 @@ fn block1(number: BlockNumber) -> (SealedBlockWithSenders, ExecutionOutcome) {
b256!("5d035ccb3e75a9057452ff060b773b213ec1fc353426174068edfc3971a0b6bd")
);
let (header, mut body) = TEST_BLOCK.clone().split();
let (mut header, mut body) = TEST_BLOCK.clone().split_header_body();
body.withdrawals = Some(Withdrawals::new(vec![Withdrawal::default()]));
let mut header = header.unseal();
header.number = number;
header.state_root = state_root;
header.parent_hash = B256::ZERO;
let block = SealedBlock::new(SealedHeader::seal(header), body);
let block = SealedBlock::seal_parts(header, body);
(
SealedBlockWithSenders::new_unchecked(block, vec![Address::new([0x30; 20])]),
execution_outcome,
)
(RecoveredBlock::new_sealed(block, vec![Address::new([0x30; 20])]), execution_outcome)
}
/// Block two that points to block 1
@ -251,7 +247,7 @@ fn block2(
number: BlockNumber,
parent_hash: B256,
prev_execution_outcome: &ExecutionOutcome,
) -> (SealedBlockWithSenders, ExecutionOutcome) {
) -> (RecoveredBlock<reth_primitives::Block>, ExecutionOutcome) {
// block changes
let account: Address = [0x60; 20].into();
let slot = U256::from(5);
@ -297,20 +293,16 @@ fn block2(
b256!("90101a13dd059fa5cca99ed93d1dc23657f63626c5b8f993a2ccbdf7446b64f8")
);
let (header, mut body) = TEST_BLOCK.clone().split();
let (mut header, mut body) = TEST_BLOCK.clone().split_header_body();
body.withdrawals = Some(Withdrawals::new(vec![Withdrawal::default()]));
let mut header = header.unseal();
header.number = number;
header.state_root = state_root;
// parent_hash points to block1 hash
header.parent_hash = parent_hash;
let block = SealedBlock::new(SealedHeader::seal(header), body);
let block = SealedBlock::seal_parts(header, body);
(
SealedBlockWithSenders::new_unchecked(block, vec![Address::new([0x31; 20])]),
execution_outcome,
)
(RecoveredBlock::new_sealed(block, vec![Address::new([0x31; 20])]), execution_outcome)
}
/// Block three that points to block 2
@ -318,7 +310,7 @@ fn block3(
number: BlockNumber,
parent_hash: B256,
prev_execution_outcome: &ExecutionOutcome,
) -> (SealedBlockWithSenders, ExecutionOutcome) {
) -> (RecoveredBlock<reth_primitives::Block>, ExecutionOutcome) {
let address_range = 1..=20;
let slot_range = 1..=100;
@ -365,19 +357,15 @@ fn block3(
extended.extend(execution_outcome.clone());
let state_root = bundle_state_root(&extended);
let (header, mut body) = TEST_BLOCK.clone().split();
let (mut header, mut body) = TEST_BLOCK.clone().split_header_body();
body.withdrawals = Some(Withdrawals::new(vec![Withdrawal::default()]));
let mut header = header.unseal();
header.number = number;
header.state_root = state_root;
// parent_hash points to block1 hash
header.parent_hash = parent_hash;
let block = SealedBlock::new(SealedHeader::seal(header), body);
let block = SealedBlock::seal_parts(header, body);
(
SealedBlockWithSenders::new_unchecked(block, vec![Address::new([0x31; 20])]),
execution_outcome,
)
(RecoveredBlock::new_sealed(block, vec![Address::new([0x31; 20])]), execution_outcome)
}
/// Block four that points to block 3
@ -385,7 +373,7 @@ fn block4(
number: BlockNumber,
parent_hash: B256,
prev_execution_outcome: &ExecutionOutcome,
) -> (SealedBlockWithSenders, ExecutionOutcome) {
) -> (RecoveredBlock<reth_primitives::Block>, ExecutionOutcome) {
let address_range = 1..=20;
let slot_range = 1..=100;
@ -457,19 +445,15 @@ fn block4(
extended.extend(execution_outcome.clone());
let state_root = bundle_state_root(&extended);
let (header, mut body) = TEST_BLOCK.clone().split();
let (mut header, mut body) = TEST_BLOCK.clone().split_header_body();
body.withdrawals = Some(Withdrawals::new(vec![Withdrawal::default()]));
let mut header = header.unseal();
header.number = number;
header.state_root = state_root;
// parent_hash points to block1 hash
header.parent_hash = parent_hash;
let block = SealedBlock::new(SealedHeader::seal(header), body);
let block = SealedBlock::seal_parts(header, body);
(
SealedBlockWithSenders::new_unchecked(block, vec![Address::new([0x31; 20])]),
execution_outcome,
)
(RecoveredBlock::new_sealed(block, vec![Address::new([0x31; 20])]), execution_outcome)
}
/// Block five that points to block 4
@ -477,7 +461,7 @@ fn block5(
number: BlockNumber,
parent_hash: B256,
prev_execution_outcome: &ExecutionOutcome,
) -> (SealedBlockWithSenders, ExecutionOutcome) {
) -> (RecoveredBlock<reth_primitives::Block>, ExecutionOutcome) {
let address_range = 1..=20;
let slot_range = 1..=100;
@ -546,17 +530,13 @@ fn block5(
extended.extend(execution_outcome.clone());
let state_root = bundle_state_root(&extended);
let (header, mut body) = TEST_BLOCK.clone().split();
let (mut header, mut body) = TEST_BLOCK.clone().split_header_body();
body.withdrawals = Some(Withdrawals::new(vec![Withdrawal::default()]));
let mut header = header.unseal();
header.number = number;
header.state_root = state_root;
// parent_hash points to block1 hash
header.parent_hash = parent_hash;
let block = SealedBlock::new(SealedHeader::seal(header), body);
let block = SealedBlock::seal_parts(header, body);
(
SealedBlockWithSenders::new_unchecked(block, vec![Address::new([0x31; 20])]),
execution_outcome,
)
(RecoveredBlock::new_sealed(block, vec![Address::new([0x31; 20])]), execution_outcome)
}

22
crates/storage/provider/src/test_utils/mock.rs
View File

@ -19,8 +19,8 @@ use reth_db_api::models::{AccountBeforeTx, StoredBlockBodyIndices};
use reth_execution_types::ExecutionOutcome;
use reth_node_types::NodeTypes;
use reth_primitives::{
Account, Block, BlockWithSenders, Bytecode, EthPrimitives, GotExpected, Receipt, SealedBlock,
SealedBlockWithSenders, SealedHeader, TransactionSigned,
Account, Block, Bytecode, EthPrimitives, GotExpected, Receipt, RecoveredBlock, SealedBlock,
SealedHeader, TransactionSigned,
};
use reth_primitives_traits::SignedTransaction;
use reth_stages_types::{StageCheckpoint, StageId};
@ -220,7 +220,7 @@ impl HeaderProvider for MockEthProvider {
}
fn sealed_header(&self, number: BlockNumber) -> ProviderResult<Option<SealedHeader>> {
Ok(self.header_by_number(number)?.map(SealedHeader::seal))
Ok(self.header_by_number(number)?.map(SealedHeader::seal_slow))
}
fn sealed_headers_while(
@ -231,7 +231,7 @@ impl HeaderProvider for MockEthProvider {
Ok(self
.headers_range(range)?
.into_iter()
.map(SealedHeader::seal)
.map(SealedHeader::seal_slow)
.take_while(|h| predicate(h))
.collect())
}
@ -497,7 +497,9 @@ impl BlockReader for MockEthProvider {
Ok(None)
}
fn pending_block_with_senders(&self) -> ProviderResult<Option<SealedBlockWithSenders>> {
fn pending_block_with_senders(
&self,
) -> ProviderResult<Option<RecoveredBlock<reth_primitives::Block>>> {
Ok(None)
}
@ -509,7 +511,7 @@ impl BlockReader for MockEthProvider {
&self,
_id: BlockHashOrNumber,
_transaction_kind: TransactionVariant,
) -> ProviderResult<Option<BlockWithSenders>> {
) -> ProviderResult<Option<RecoveredBlock<reth_primitives::Block>>> {
Ok(None)
}
@ -517,7 +519,7 @@ impl BlockReader for MockEthProvider {
&self,
_id: BlockHashOrNumber,
_transaction_kind: TransactionVariant,
) -> ProviderResult<Option<SealedBlockWithSenders>> {
) -> ProviderResult<Option<RecoveredBlock<reth_primitives::Block>>> {
Ok(None)
}
@ -534,14 +536,14 @@ impl BlockReader for MockEthProvider {
fn block_with_senders_range(
&self,
_range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<BlockWithSenders>> {
) -> ProviderResult<Vec<RecoveredBlock<reth_primitives::Block>>> {
Ok(vec![])
}
fn sealed_block_with_senders_range(
&self,
_range: RangeInclusive<BlockNumber>,
) -> ProviderResult<Vec<SealedBlockWithSenders>> {
) -> ProviderResult<Vec<RecoveredBlock<reth_primitives::Block>>> {
Ok(vec![])
}
}
@ -555,7 +557,7 @@ impl BlockReaderIdExt for MockEthProvider {
}
fn sealed_header_by_id(&self, id: BlockId) -> ProviderResult<Option<SealedHeader>> {
self.header_by_id(id)?.map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal(h))))
self.header_by_id(id)?.map_or_else(|| Ok(None), |h| Ok(Some(SealedHeader::seal_slow(h))))
}
fn header_by_id(&self, id: BlockId) -> ProviderResult<Option<Header>> {

8
crates/storage/provider/src/traits/block.rs
View File

@ -2,7 +2,7 @@ use alloy_primitives::BlockNumber;
use reth_db_api::models::StoredBlockBodyIndices;
use reth_execution_types::{Chain, ExecutionOutcome};
use reth_node_types::NodePrimitives;
use reth_primitives::SealedBlockWithSenders;
use reth_primitives::RecoveredBlock;
use reth_storage_api::{NodePrimitivesProvider, StorageLocation};
use reth_storage_errors::provider::ProviderResult;
use reth_trie::{updates::TrieUpdates, HashedPostStateSorted};
@ -85,7 +85,7 @@ pub trait BlockWriter: Send + Sync {
/// written.
fn insert_block(
&self,
block: SealedBlockWithSenders<Self::Block>,
block: RecoveredBlock<Self::Block>,
write_to: StorageLocation,
) -> ProviderResult<StoredBlockBodyIndices>;
@ -124,7 +124,7 @@ pub trait BlockWriter: Send + Sync {
///
/// # Parameters
///
/// - `blocks`: Vector of `SealedBlockWithSenders` instances to append.
/// - `blocks`: Vector of `RecoveredBlock` instances to append.
/// - `state`: Post-state information to update after appending.
///
/// # Returns
@ -132,7 +132,7 @@ pub trait BlockWriter: Send + Sync {
/// Returns `Ok(())` on success, or an error if any operation fails.
fn append_blocks_with_state(
&self,
blocks: Vec<SealedBlockWithSenders<Self::Block>>,
blocks: Vec<RecoveredBlock<Self::Block>>,
execution_outcome: &ExecutionOutcome<Self::Receipt>,
hashed_state: HashedPostStateSorted,
trie_updates: TrieUpdates,

4
crates/storage/provider/src/traits/header_sync_gap.rs
View File

@ -1,6 +1,6 @@
use alloy_consensus::{BlockHeader, Header};
use alloy_eips::BlockHashOrNumber;
use alloy_primitives::{BlockNumber, B256};
use alloy_primitives::{BlockNumber, Sealable, B256};
use reth_network_p2p::headers::downloader::SyncTarget;
use reth_primitives::SealedHeader;
use reth_storage_errors::provider::ProviderResult;
@ -16,7 +16,7 @@ pub struct HeaderSyncGap<H = Header> {
pub target: SyncTarget,
}
impl<H: BlockHeader> HeaderSyncGap<H> {
impl<H: BlockHeader + Sealable> HeaderSyncGap<H> {
/// Returns `true` if the gap from the head to the target was closed
#[inline]
pub fn is_closed(&self) -> bool {