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

feat: update el requests for devnet 4 (#11865)

Browse Source 
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
This commit is contained in:
Oliver
2024-10-19 14:48:35 +02:00
committed by GitHub
parent 2ae93682b4
commit 3bd695ee63
106 changed files with 799 additions and 1328 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
crates/storage/codecs/src/alloy/authorization_list.rs
View File

@ -13,7 +13,7 @@ use reth_codecs_derive::add_arbitrary_tests;
#[cfg_attr(test, derive(arbitrary::Arbitrary, serde::Serialize, serde::Deserialize))]
#[add_arbitrary_tests(compact)]
pub(crate) struct Authorization {
chain_id: U256,
chain_id: u64,
address: Address,
nonce: u64,
}
@ -78,7 +78,7 @@ mod tests {
#[test]
fn test_roundtrip_compact_authorization_list_item() {
let authorization = AlloyAuthorization {
chain_id: U256::from(1),
chain_id: 1u64,
address: address!("dac17f958d2ee523a2206206994597c13d831ec7"),
nonce: 1,
}

10
crates/storage/codecs/src/alloy/header.rs
View File

@ -45,7 +45,7 @@ pub(crate) struct Header {
#[cfg_attr(test, derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Compact)]
pub(crate) struct HeaderExt {
requests_root: Option<B256>,
requests_hash: Option<B256>,
}
impl HeaderExt {
@ -53,7 +53,7 @@ impl HeaderExt {
///
/// Required since [`Header`] uses `Option<HeaderExt>` as a field.
const fn into_option(self) -> Option<Self> {
if self.requests_root.is_some() {
if self.requests_hash.is_some() {
Some(self)
} else {
None
@ -66,7 +66,7 @@ impl Compact for AlloyHeader {
where
B: bytes::BufMut + AsMut<[u8]>,
{
let extra_fields = HeaderExt { requests_root: self.requests_root };
let extra_fields = HeaderExt { requests_hash: self.requests_hash };
let header = Header {
parent_hash: self.parent_hash,
@ -116,7 +116,7 @@ impl Compact for AlloyHeader {
blob_gas_used: header.blob_gas_used,
excess_blob_gas: header.excess_blob_gas,
parent_beacon_block_root: header.parent_beacon_block_root,
requests_root: header.extra_fields.and_then(|h| h.requests_root),
requests_hash: header.extra_fields.and_then(|h| h.requests_hash),
extra_data: header.extra_data,
};
(alloy_header, buf)
@ -176,7 +176,7 @@ mod tests {
#[test]
fn test_extra_fields() {
let mut header = HOLESKY_BLOCK;
header.extra_fields = Some(HeaderExt { requests_root: Some(B256::random()) });
header.extra_fields = Some(HeaderExt { requests_hash: Some(B256::random()) });
let mut encoded_header = vec![];
let len = header.to_compact(&mut encoded_header);

3
crates/storage/codecs/src/alloy/mod.rs
View File

@ -3,7 +3,6 @@ mod authorization_list;
mod genesis_account;
mod header;
mod log;
mod request;
mod signature;
mod transaction;
mod trie;
@ -14,7 +13,6 @@ mod withdrawal;
mod tests {
use crate::{
alloy::{
authorization_list::Authorization,
genesis_account::{GenesisAccount, GenesisAccountRef, StorageEntries, StorageEntry},
header::{Header, HeaderExt},
transaction::{
@ -38,7 +36,6 @@ mod tests {
validate_bitflag_backwards_compat!(StorageEntries, UnusedBits::Zero);
validate_bitflag_backwards_compat!(StorageEntry, UnusedBits::Zero);
validate_bitflag_backwards_compat!(Authorization, UnusedBits::NotZero);
validate_bitflag_backwards_compat!(GenesisAccountRef<'_>, UnusedBits::NotZero);
validate_bitflag_backwards_compat!(GenesisAccount, UnusedBits::NotZero);
validate_bitflag_backwards_compat!(TxEip1559, UnusedBits::NotZero);

40
crates/storage/codecs/src/alloy/request.rs
View File

@ -1,40 +0,0 @@
//! Native Compact codec impl for EIP-7685 requests.
use crate::Compact;
use alloy_consensus::Request;
use alloy_eips::eip7685::{Decodable7685, Encodable7685};
use alloy_primitives::Bytes;
use bytes::BufMut;
impl Compact for Request {
fn to_compact<B>(&self, buf: &mut B) -> usize
where
B: BufMut + AsMut<[u8]>,
{
let encoded: Bytes = self.encoded_7685().into();
encoded.to_compact(buf)
}
fn from_compact(buf: &[u8], _: usize) -> (Self, &[u8]) {
let (raw, buf) = Bytes::from_compact(buf, buf.len());
(Self::decode_7685(&mut raw.as_ref()).expect("invalid eip-7685 request in db"), buf)
}
}
#[cfg(test)]
mod tests {
use super::*;
use proptest::proptest;
use proptest_arbitrary_interop::arb;
proptest! {
#[test]
fn roundtrip(request in arb::<Request>()) {
let mut buf = Vec::<u8>::new();
request.to_compact(&mut buf);
let (decoded, _) = Request::from_compact(&buf, buf.len());
assert_eq!(request, decoded);
}
}
}

4
crates/storage/db-api/src/models/mod.rs
View File

@ -8,7 +8,7 @@ use alloy_genesis::GenesisAccount;
use alloy_primitives::{Address, Bytes, Log, B256, U256};
use reth_codecs::{add_arbitrary_tests, Compact};
use reth_primitives::{
Account, Bytecode, Header, Receipt, Requests, StorageEntry, TransactionSignedNoHash, TxType,
Account, Bytecode, Header, Receipt, StorageEntry, TransactionSignedNoHash, TxType,
};
use reth_prune_types::{PruneCheckpoint, PruneSegment};
use reth_stages_types::StageCheckpoint;
@ -230,7 +230,6 @@ impl_compression_for_compact!(
StageCheckpoint,
PruneCheckpoint,
ClientVersion,
Requests,
// Non-DB
GenesisAccount
);
@ -366,6 +365,5 @@ mod tests {
validate_bitflag_backwards_compat!(StoredBlockWithdrawals, UnusedBits::Zero);
validate_bitflag_backwards_compat!(StorageHashingCheckpoint, UnusedBits::NotZero);
validate_bitflag_backwards_compat!(Withdrawals, UnusedBits::Zero);
validate_bitflag_backwards_compat!(Requests, UnusedBits::Zero);
}
}

7
crates/storage/db/src/tables/mod.rs
View File

@ -30,9 +30,7 @@ use reth_db_api::{
},
table::{Decode, DupSort, Encode, Table},
};
use reth_primitives::{
Account, Bytecode, Header, Receipt, Requests, StorageEntry, TransactionSignedNoHash,
};
use reth_primitives::{Account, Bytecode, Header, Receipt, StorageEntry, TransactionSignedNoHash};
use reth_primitives_traits::IntegerList;
use reth_prune_types::{PruneCheckpoint, PruneSegment};
use reth_stages_types::StageCheckpoint;
@ -404,9 +402,6 @@ tables! {
/// Stores the history of client versions that have accessed the database with write privileges by unix timestamp in seconds.
table VersionHistory<Key = u64, Value = ClientVersion>;
/// Stores EIP-7685 EL -> CL requests, indexed by block number.
table BlockRequests<Key = BlockNumber, Value = Requests>;
/// Stores generic chain state info, like the last finalized block.
table ChainState<Key = ChainStateKey, Value = BlockNumber>;
}

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

@ -4,7 +4,7 @@ use crate::{
CanonStateSubscriptions, ChainSpecProvider, ChainStateBlockReader, ChangeSetReader,
DatabaseProviderFactory, DatabaseProviderRO, EvmEnvProvider, HeaderProvider, ProviderError,
ProviderFactory, PruneCheckpointReader, ReceiptProvider, ReceiptProviderIdExt,
RequestsProvider, StageCheckpointReader, StateProviderBox, StateProviderFactory, StateReader,
StageCheckpointReader, StateProviderBox, StateProviderFactory, StateReader,
StaticFileProviderFactory, TransactionVariant, TransactionsProvider, WithdrawalsProvider,
};
use alloy_eips::{BlockHashOrNumber, BlockId, BlockNumHash, BlockNumberOrTag, HashOrNumber};
@ -1200,24 +1200,6 @@ impl<N: ProviderNodeTypes> WithdrawalsProvider for BlockchainProvider2<N> {
}
}
impl<N: ProviderNodeTypes> RequestsProvider for BlockchainProvider2<N> {
fn requests_by_block(
&self,
id: BlockHashOrNumber,
timestamp: u64,
) -> ProviderResult<Option<reth_primitives::Requests>> {
if !self.chain_spec().is_prague_active_at_timestamp(timestamp) {
return Ok(None)
}
self.get_in_memory_or_storage_by_block(
id,
|db_provider| db_provider.requests_by_block(id, timestamp),
|block_state| Ok(block_state.block_ref().block().body.requests.clone()),
)
}
}
impl<N: ProviderNodeTypes> StageCheckpointReader for BlockchainProvider2<N> {
fn get_stage_checkpoint(&self, id: StageId) -> ProviderResult<Option<StageCheckpoint>> {
self.database.provider()?.get_stage_checkpoint(id)
@ -1747,8 +1729,8 @@ mod tests {
use reth_storage_api::{
BlockHashReader, BlockIdReader, BlockNumReader, BlockReader, BlockReaderIdExt, BlockSource,
ChangeSetReader, DatabaseProviderFactory, HeaderProvider, ReceiptProvider,
ReceiptProviderIdExt, RequestsProvider, StateProviderFactory, TransactionVariant,
TransactionsProvider, WithdrawalsProvider,
ReceiptProviderIdExt, StateProviderFactory, TransactionVariant, TransactionsProvider,
WithdrawalsProvider,
};
use reth_testing_utils::generators::{
self, random_block, random_block_range, random_changeset_range, random_eoa_accounts,
@ -2849,37 +2831,6 @@ mod tests {
Ok(())
}
#[test]
fn test_requests_provider() -> eyre::Result<()> {
let mut rng = generators::rng();
let chain_spec = Arc::new(ChainSpecBuilder::mainnet().prague_activated().build());
let (provider, database_blocks, in_memory_blocks, _) =
provider_with_chain_spec_and_random_blocks(
&mut rng,
chain_spec.clone(),
TEST_BLOCKS_COUNT,
TEST_BLOCKS_COUNT,
BlockRangeParams { requests_count: Some(1..2), ..Default::default() },
)?;
let database_block = database_blocks.first().unwrap().clone();
let in_memory_block = in_memory_blocks.last().unwrap().clone();
let prague_timestamp =
chain_spec.hardforks.fork(EthereumHardfork::Prague).as_timestamp().unwrap();
assert_eq!(
provider.requests_by_block(database_block.number.into(), prague_timestamp,)?,
database_block.body.requests.clone()
);
assert_eq!(
provider.requests_by_block(in_memory_block.number.into(), prague_timestamp,)?,
in_memory_block.body.requests.clone()
);
Ok(())
}
#[test]
fn test_state_provider_factory() -> eyre::Result<()> {
let mut rng = generators::rng();

4
crates/storage/provider/src/providers/database/metrics.rs
View File

@ -61,7 +61,6 @@ pub(crate) enum Action {
InsertTransactions,
InsertTransactionHashNumbers,
InsertBlockWithdrawals,
InsertBlockRequests,
InsertBlockBodyIndices,
InsertTransactionBlocks,
GetNextTxNum,
@ -106,8 +105,6 @@ struct DatabaseProviderMetrics {
insert_tx_hash_numbers: Histogram,
/// Duration of insert block withdrawals
insert_block_withdrawals: Histogram,
/// Duration of insert block requests
insert_block_requests: Histogram,
/// Duration of insert block body indices
insert_block_body_indices: Histogram,
/// Duration of insert transaction blocks
@ -139,7 +136,6 @@ impl DatabaseProviderMetrics {
Action::InsertTransactions => self.insert_transactions.record(duration),
Action::InsertTransactionHashNumbers => self.insert_tx_hash_numbers.record(duration),
Action::InsertBlockWithdrawals => self.insert_block_withdrawals.record(duration),
Action::InsertBlockRequests => self.insert_block_requests.record(duration),
Action::InsertBlockBodyIndices => self.insert_block_body_indices.record(duration),
Action::InsertTransactionBlocks => self.insert_tx_blocks.record(duration),
Action::GetNextTxNum => self.get_next_tx_num.record(duration),

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

@ -4,8 +4,8 @@ use crate::{
traits::{BlockSource, ReceiptProvider},
BlockHashReader, BlockNumReader, BlockReader, ChainSpecProvider, DatabaseProviderFactory,
EvmEnvProvider, HeaderProvider, HeaderSyncGap, HeaderSyncGapProvider, ProviderError,
PruneCheckpointReader, RequestsProvider, StageCheckpointReader, StateProviderBox,
StaticFileProviderFactory, TransactionVariant, TransactionsProvider, WithdrawalsProvider,
PruneCheckpointReader, StageCheckpointReader, StateProviderBox, StaticFileProviderFactory,
TransactionVariant, TransactionsProvider, WithdrawalsProvider,
};
use alloy_eips::BlockHashOrNumber;
use alloy_primitives::{Address, BlockHash, BlockNumber, TxHash, TxNumber, B256, U256};
@ -519,16 +519,6 @@ impl<N: ProviderNodeTypes> WithdrawalsProvider for ProviderFactory<N> {
}
}
impl<N: ProviderNodeTypes> RequestsProvider for ProviderFactory<N> {
fn requests_by_block(
&self,
id: BlockHashOrNumber,
timestamp: u64,
) -> ProviderResult<Option<reth_primitives::Requests>> {
self.provider()?.requests_by_block(id, timestamp)
}
}
impl<N: ProviderNodeTypes> StageCheckpointReader for ProviderFactory<N> {
fn get_stage_checkpoint(&self, id: StageId) -> ProviderResult<Option<StageCheckpoint>> {
self.provider()?.get_stage_checkpoint(id)

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

@ -11,10 +11,10 @@ use crate::{
DBProvider, EvmEnvProvider, HashingWriter, HeaderProvider, HeaderSyncGap,
HeaderSyncGapProvider, HistoricalStateProvider, HistoricalStateProviderRef, HistoryWriter,
LatestStateProvider, LatestStateProviderRef, OriginalValuesKnown, ProviderError,
PruneCheckpointReader, PruneCheckpointWriter, RequestsProvider, RevertsInit,
StageCheckpointReader, StateChangeWriter, StateProviderBox, StateReader, StateWriter,
StaticFileProviderFactory, StatsReader, StorageReader, StorageTrieWriter, TransactionVariant,
TransactionsProvider, TransactionsProviderExt, TrieWriter, WithdrawalsProvider,
PruneCheckpointReader, PruneCheckpointWriter, RevertsInit, StageCheckpointReader,
StateChangeWriter, StateProviderBox, StateReader, StateWriter, StaticFileProviderFactory,
StatsReader, StorageReader, StorageTrieWriter, TransactionVariant, TransactionsProvider,
TransactionsProviderExt, TrieWriter, WithdrawalsProvider,
};
use alloy_eips::BlockHashOrNumber;
use alloy_primitives::{keccak256, Address, BlockHash, BlockNumber, TxHash, TxNumber, B256, U256};
@ -40,7 +40,7 @@ use reth_evm::ConfigureEvmEnv;
use reth_execution_types::{Chain, ExecutionOutcome};
use reth_network_p2p::headers::downloader::SyncTarget;
use reth_primitives::{
Account, Block, BlockBody, BlockWithSenders, Bytecode, GotExpected, Header, Receipt, Requests,
Account, Block, BlockBody, BlockWithSenders, Bytecode, GotExpected, Header, Receipt,
SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment, StorageEntry,
TransactionMeta, TransactionSigned, TransactionSignedEcRecovered, TransactionSignedNoHash,
Withdrawal, Withdrawals,
@ -500,7 +500,6 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
Vec<Address>,
Vec<Header>,
Option<Withdrawals>,
Option<Requests>,
) -> ProviderResult<Option<B>>,
{
let Some(block_number) = self.convert_hash_or_number(id)? else { return Ok(None) };
@ -509,7 +508,6 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
let ommers = self.ommers(block_number.into())?.unwrap_or_default();
let withdrawals =
self.withdrawals_by_block(block_number.into(), header.as_ref().timestamp)?;
let requests = self.requests_by_block(block_number.into(), header.as_ref().timestamp)?;
// Get the block body
//
@ -540,7 +538,7 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
})
.collect();
construct_block(header, body, senders, ommers, withdrawals, requests)
construct_block(header, body, senders, ommers, withdrawals)
}
/// Returns a range of blocks from the database.
@ -551,7 +549,6 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
/// - Range of transaction numbers
/// – Ommers
/// – Withdrawals
/// – Requests
/// – Senders
fn block_range<F, H, HF, R>(
&self,
@ -563,13 +560,7 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
Spec: EthereumHardforks,
H: AsRef<Header>,
HF: FnOnce(RangeInclusive<BlockNumber>) -> ProviderResult<Vec<H>>,
F: FnMut(
H,
Range<TxNumber>,
Vec<Header>,
Option<Withdrawals>,
Option<Requests>,
) -> ProviderResult<R>,
F: FnMut(H, Range<TxNumber>, Vec<Header>, Option<Withdrawals>) -> ProviderResult<R>,
{
if range.is_empty() {
return Ok(Vec::new())
@ -581,7 +572,6 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
let headers = headers_range(range)?;
let mut ommers_cursor = self.tx.cursor_read::<tables::BlockOmmers>()?;
let mut withdrawals_cursor = self.tx.cursor_read::<tables::BlockWithdrawals>()?;
let mut requests_cursor = self.tx.cursor_read::<tables::BlockRequests>()?;
let mut block_body_cursor = self.tx.cursor_read::<tables::BlockBodyIndices>()?;
for header in headers {
@ -608,13 +598,6 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
} else {
None
};
let requests =
if self.chain_spec.is_prague_active_at_timestamp(header_ref.timestamp) {
(requests_cursor.seek_exact(header_ref.number)?.unwrap_or_default().1)
.into()
} else {
None
};
let ommers =
if self.chain_spec.final_paris_total_difficulty(header_ref.number).is_some() {
Vec::new()
@ -625,7 +608,7 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
.unwrap_or_default()
};
if let Ok(b) = assemble_block(header, tx_range, ommers, withdrawals, requests) {
if let Ok(b) = assemble_block(header, tx_range, ommers, withdrawals) {
blocks.push(b);
}
}
@ -643,7 +626,6 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
/// - Transactions
/// – Ommers
/// – Withdrawals
/// – Requests
/// – Senders
fn block_with_senders_range<H, HF, B, BF>(
&self,
@ -660,14 +642,13 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
Vec<TransactionSigned>,
Vec<Header>,
Option<Withdrawals>,
Option<Requests>,
Vec<Address>,
) -> ProviderResult<B>,
{
let mut tx_cursor = self.tx.cursor_read::<tables::Transactions>()?;
let mut senders_cursor = self.tx.cursor_read::<tables::TransactionSenders>()?;
self.block_range(range, headers_range, |header, tx_range, ommers, withdrawals, requests| {
self.block_range(range, headers_range, |header, tx_range, ommers, withdrawals| {
let (body, senders) = if tx_range.is_empty() {
(Vec::new(), Vec::new())
} else {
@ -699,7 +680,7 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
(body, senders)
};
assemble_block(header, body, ommers, withdrawals, requests, senders)
assemble_block(header, body, ommers, withdrawals, senders)
})
}
@ -781,7 +762,6 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
// - Bodies (transactions)
// - Uncles/ommers
// - Withdrawals
// - Requests
// - Signers
let block_headers = self.get::<tables::Headers>(range.clone())?;
@ -792,7 +772,6 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
let block_header_hashes = self.get::<tables::CanonicalHeaders>(range.clone())?;
let block_ommers = self.get::<tables::BlockOmmers>(range.clone())?;
let block_withdrawals = self.get::<tables::BlockWithdrawals>(range.clone())?;
let block_requests = self.get::<tables::BlockRequests>(range.clone())?;
let block_tx = self.get_block_transaction_range(range)?;
let mut blocks = Vec::with_capacity(block_headers.len());
@ -805,10 +784,8 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
// Ommers can be empty for some blocks
let mut block_ommers_iter = block_ommers.into_iter();
let mut block_withdrawals_iter = block_withdrawals.into_iter();
let mut block_requests_iter = block_requests.into_iter();
let mut block_ommers = block_ommers_iter.next();
let mut block_withdrawals = block_withdrawals_iter.next();
let mut block_requests = block_requests_iter.next();
for ((main_block_number, header), (_, header_hash), (_, tx)) in
izip!(block_header_iter, block_header_hashes_iter, block_tx_iter)
@ -841,24 +818,10 @@ impl<TX: DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
withdrawals = None
}
// requests can be missing
let prague_is_active = self.chain_spec.is_prague_active_at_timestamp(header.timestamp);
let mut requests = Some(Requests::default());
if prague_is_active {
if let Some((block_number, _)) = block_requests.as_ref() {
if *block_number == main_block_number {
requests = Some(block_requests.take().unwrap().1);
block_requests = block_requests_iter.next();
}
}
} else {
requests = None;
}
blocks.push(SealedBlockWithSenders {
block: SealedBlock {
header,
body: BlockBody { transactions, ommers, withdrawals, requests },
body: BlockBody { transactions, ommers, withdrawals },
},
senders,
})
@ -1222,7 +1185,6 @@ impl<TX: DbTxMut + DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
/// * [`CanonicalHeaders`](tables::CanonicalHeaders)
/// * [`BlockOmmers`](tables::BlockOmmers)
/// * [`BlockWithdrawals`](tables::BlockWithdrawals)
/// * [`BlockRequests`](tables::BlockRequests)
/// * [`HeaderTerminalDifficulties`](tables::HeaderTerminalDifficulties)
///
/// This will also remove transaction data according to
@ -1242,7 +1204,6 @@ impl<TX: DbTxMut + DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
self.remove::<tables::CanonicalHeaders>(range.clone())?;
self.remove::<tables::BlockOmmers>(range.clone())?;
self.remove::<tables::BlockWithdrawals>(range.clone())?;
self.remove::<tables::BlockRequests>(range.clone())?;
self.remove_block_transaction_range(range.clone())?;
self.remove::<tables::HeaderTerminalDifficulties>(range)?;
@ -1256,7 +1217,6 @@ impl<TX: DbTxMut + DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
/// * [`CanonicalHeaders`](tables::CanonicalHeaders)
/// * [`BlockOmmers`](tables::BlockOmmers)
/// * [`BlockWithdrawals`](tables::BlockWithdrawals)
/// * [`BlockRequests`](tables::BlockRequests)
/// * [`HeaderTerminalDifficulties`](tables::HeaderTerminalDifficulties)
///
/// This will also remove transaction data according to
@ -1274,7 +1234,6 @@ impl<TX: DbTxMut + DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
// - Bodies (transactions)
// - Uncles/ommers
// - Withdrawals
// - Requests
// - Signers
let block_headers = self.take::<tables::Headers>(range.clone())?;
@ -1288,7 +1247,6 @@ impl<TX: DbTxMut + DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
let block_header_hashes = self.take::<tables::CanonicalHeaders>(range.clone())?;
let block_ommers = self.take::<tables::BlockOmmers>(range.clone())?;
let block_withdrawals = self.take::<tables::BlockWithdrawals>(range.clone())?;
let block_requests = self.take::<tables::BlockRequests>(range.clone())?;
let block_tx = self.take_block_transaction_range(range.clone())?;
let mut blocks = Vec::with_capacity(block_headers.len());
@ -1304,10 +1262,8 @@ impl<TX: DbTxMut + DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
// Ommers can be empty for some blocks
let mut block_ommers_iter = block_ommers.into_iter();
let mut block_withdrawals_iter = block_withdrawals.into_iter();
let mut block_requests_iter = block_requests.into_iter();
let mut block_ommers = block_ommers_iter.next();
let mut block_withdrawals = block_withdrawals_iter.next();
let mut block_requests = block_requests_iter.next();
for ((main_block_number, header), (_, header_hash), (_, tx)) in
izip!(block_header_iter, block_header_hashes_iter, block_tx_iter)
@ -1340,24 +1296,10 @@ impl<TX: DbTxMut + DbTx, Spec: Send + Sync> DatabaseProvider<TX, Spec> {
withdrawals = None
}
// requests can be missing
let prague_is_active = self.chain_spec.is_prague_active_at_timestamp(header.timestamp);
let mut requests = Some(Requests::default());
if prague_is_active {
if let Some((block_number, _)) = block_requests.as_ref() {
if *block_number == main_block_number {
requests = Some(block_requests.take().unwrap().1);
block_requests = block_requests_iter.next();
}
}
} else {
requests = None;
}
blocks.push(SealedBlockWithSenders {
block: SealedBlock {
header,
body: BlockBody { transactions, ommers, withdrawals, requests },
body: BlockBody { transactions, ommers, withdrawals },
},
senders,
})
@ -1726,7 +1668,6 @@ impl<TX: DbTx, Spec: Send + Sync + EthereumHardforks> BlockReader for DatabasePr
if let Some(header) = self.header_by_number(number)? {
let withdrawals = self.withdrawals_by_block(number.into(), header.timestamp)?;
let ommers = self.ommers(number.into())?.unwrap_or_default();
let requests = self.requests_by_block(number.into(), header.timestamp)?;
// If the body indices are not found, this means that the transactions either do not
// exist in the database yet, or they do exit but are not indexed.
// If they exist but are not indexed, we don't have enough
@ -1738,7 +1679,7 @@ impl<TX: DbTx, Spec: Send + Sync + EthereumHardforks> BlockReader for DatabasePr
return Ok(Some(Block {
header,
body: BlockBody { transactions, ommers, withdrawals, requests },
body: BlockBody { transactions, ommers, withdrawals },
}))
}
}
@ -1798,8 +1739,8 @@ impl<TX: DbTx, Spec: Send + Sync + EthereumHardforks> BlockReader for DatabasePr
id,
transaction_kind,
|block_number| self.header_by_number(block_number),
|header, transactions, senders, ommers, withdrawals, requests| {
Block { header, body: BlockBody { transactions, ommers, withdrawals, requests } }
|header, transactions, senders, ommers, withdrawals| {
Block { header, body: BlockBody { transactions, ommers, withdrawals } }
// 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
@ -1819,17 +1760,14 @@ impl<TX: DbTx, Spec: Send + Sync + EthereumHardforks> BlockReader for DatabasePr
id,
transaction_kind,
|block_number| self.sealed_header(block_number),
|header, transactions, senders, ommers, withdrawals, requests| {
SealedBlock {
header,
body: BlockBody { transactions, ommers, withdrawals, requests },
}
// 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
.try_with_senders_unchecked(senders)
.map(Some)
.map_err(|_| ProviderError::SenderRecoveryError)
|header, transactions, senders, ommers, withdrawals| {
SealedBlock { header, body: BlockBody { transactions, ommers, withdrawals } }
// 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
.try_with_senders_unchecked(senders)
.map(Some)
.map_err(|_| ProviderError::SenderRecoveryError)
},
)
}
@ -1839,7 +1777,7 @@ impl<TX: DbTx, Spec: Send + Sync + EthereumHardforks> BlockReader for DatabasePr
self.block_range(
range,
|range| self.headers_range(range),
|header, tx_range, ommers, withdrawals, requests| {
|header, tx_range, ommers, withdrawals| {
let transactions = if tx_range.is_empty() {
Vec::new()
} else {
@ -1848,10 +1786,7 @@ impl<TX: DbTx, Spec: Send + Sync + EthereumHardforks> BlockReader for DatabasePr
.map(Into::into)
.collect()
};
Ok(Block {
header,
body: BlockBody { transactions, ommers, withdrawals, requests },
})
Ok(Block { header, body: BlockBody { transactions, ommers, withdrawals } })
},
)
}
@ -1863,8 +1798,8 @@ impl<TX: DbTx, Spec: Send + Sync + EthereumHardforks> BlockReader for DatabasePr
self.block_with_senders_range(
range,
|range| self.headers_range(range),
|header, transactions, ommers, withdrawals, requests, senders| {
Block { header, body: BlockBody { transactions, ommers, withdrawals, requests } }
|header, transactions, ommers, withdrawals, senders| {
Block { header, body: BlockBody { transactions, ommers, withdrawals } }
.try_with_senders_unchecked(senders)
.map_err(|_| ProviderError::SenderRecoveryError)
},
@ -1878,12 +1813,9 @@ impl<TX: DbTx, Spec: Send + Sync + EthereumHardforks> BlockReader for DatabasePr
self.block_with_senders_range(
range,
|range| self.sealed_headers_range(range),
|header, transactions, ommers, withdrawals, requests, senders| {
|header, transactions, ommers, withdrawals, senders| {
SealedBlockWithSenders::new(
SealedBlock {
header,
body: BlockBody { transactions, ommers, withdrawals, requests },
},
SealedBlock { header, body: BlockBody { transactions, ommers, withdrawals } },
senders,
)
.ok_or(ProviderError::SenderRecoveryError)
@ -2200,24 +2132,6 @@ impl<TX: DbTx, Spec: Send + Sync + EthereumHardforks> WithdrawalsProvider
}
}
impl<TX: DbTx, Spec: Send + Sync + EthereumHardforks> RequestsProvider
for DatabaseProvider<TX, Spec>
{
fn requests_by_block(
&self,
id: BlockHashOrNumber,
timestamp: u64,
) -> ProviderResult<Option<Requests>> {
if self.chain_spec.is_prague_active_at_timestamp(timestamp) {
if let Some(number) = self.convert_hash_or_number(id)? {
let requests = self.tx.get::<tables::BlockRequests>(number)?;
return Ok(requests)
}
}
Ok(None)
}
}
impl<TX: DbTx, Spec: Send + Sync + EthereumHardforks> EvmEnvProvider
for DatabaseProvider<TX, Spec>
{
@ -3413,7 +3327,6 @@ impl<TX: DbTxMut + DbTx + 'static, Spec: Send + Sync + EthereumHardforks + 'stat
/// If ommers are not empty, this will modify [`BlockOmmers`](tables::BlockOmmers).
/// If withdrawals are not empty, this will modify
/// [`BlockWithdrawals`](tables::BlockWithdrawals).
/// If requests are not empty, this will modify [`BlockRequests`](tables::BlockRequests).
///
/// If the provider has __not__ configured full sender pruning, this will modify
/// [`TransactionSenders`](tables::TransactionSenders).
@ -3539,11 +3452,6 @@ impl<TX: DbTxMut + DbTx + 'static, Spec: Send + Sync + EthereumHardforks + 'stat
}
}
if let Some(requests) = block.block.body.requests {
self.tx.put::<tables::BlockRequests>(block_number, requests)?;
durations_recorder.record_relative(metrics::Action::InsertBlockRequests);
}
let block_indices = StoredBlockBodyIndices { first_tx_num, tx_count };
self.tx.put::<tables::BlockBodyIndices>(block_number, block_indices.clone())?;
durations_recorder.record_relative(metrics::Action::InsertBlockBodyIndices);

12
crates/storage/provider/src/providers/mod.rs
View File

@ -3,7 +3,7 @@ use crate::{
BlockSource, BlockchainTreePendingStateProvider, CanonChainTracker, CanonStateNotifications,
CanonStateSubscriptions, ChainSpecProvider, ChainStateBlockReader, ChangeSetReader,
DatabaseProviderFactory, EvmEnvProvider, FullExecutionDataProvider, HeaderProvider,
ProviderError, PruneCheckpointReader, ReceiptProvider, ReceiptProviderIdExt, RequestsProvider,
ProviderError, PruneCheckpointReader, ReceiptProvider, ReceiptProviderIdExt,
StageCheckpointReader, StateProviderBox, StateProviderFactory, StaticFileProviderFactory,
TransactionVariant, TransactionsProvider, TreeViewer, WithdrawalsProvider,
};
@ -504,16 +504,6 @@ impl<N: ProviderNodeTypes> WithdrawalsProvider for BlockchainProvider<N> {
}
}
impl<N: ProviderNodeTypes> RequestsProvider for BlockchainProvider<N> {
fn requests_by_block(
&self,
id: BlockHashOrNumber,
timestamp: u64,
) -> ProviderResult<Option<reth_primitives::Requests>> {
self.database.requests_by_block(id, timestamp)
}
}
impl<N: ProviderNodeTypes> StageCheckpointReader for BlockchainProvider<N> {
fn get_stage_checkpoint(&self, id: StageId) -> ProviderResult<Option<StageCheckpoint>> {
self.database.provider()?.get_stage_checkpoint(id)

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

@ -4,8 +4,8 @@ use super::{
};
use crate::{
to_range, BlockHashReader, BlockNumReader, BlockReader, BlockSource, HeaderProvider,
ReceiptProvider, RequestsProvider, StageCheckpointReader, StatsReader, TransactionVariant,
TransactionsProvider, TransactionsProviderExt, WithdrawalsProvider,
ReceiptProvider, StageCheckpointReader, StatsReader, TransactionVariant, TransactionsProvider,
TransactionsProviderExt, WithdrawalsProvider,
};
use alloy_eips::BlockHashOrNumber;
use alloy_primitives::{keccak256, Address, BlockHash, BlockNumber, TxHash, TxNumber, B256, U256};
@ -1642,17 +1642,6 @@ impl WithdrawalsProvider for StaticFileProvider {
}
}
impl RequestsProvider for StaticFileProvider {
fn requests_by_block(
&self,
_id: BlockHashOrNumber,
_timestamp: u64,
) -> ProviderResult<Option<reth_primitives::Requests>> {
// Required data not present in static_files
Err(ProviderError::UnsupportedProvider)
}
}
impl StatsReader for StaticFileProvider {
fn count_entries<T: Table>(&self) -> ProviderResult<usize> {
match T::NAME {

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

@ -40,7 +40,6 @@ pub fn assert_genesis_block<DB: Database, Spec: Send + Sync>(
);
assert_eq!(tx.table::<tables::BlockOmmers>().unwrap(), vec![]);
assert_eq!(tx.table::<tables::BlockWithdrawals>().unwrap(), vec![]);
assert_eq!(tx.table::<tables::BlockRequests>().unwrap(), vec![]);
assert_eq!(tx.table::<tables::Transactions>().unwrap(), vec![]);
assert_eq!(tx.table::<tables::TransactionBlocks>().unwrap(), vec![]);
assert_eq!(tx.table::<tables::TransactionHashNumbers>().unwrap(), vec![]);

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

@ -2,9 +2,9 @@ use crate::{
traits::{BlockSource, ReceiptProvider},
AccountReader, BlockExecutionReader, BlockHashReader, BlockIdReader, BlockNumReader,
BlockReader, BlockReaderIdExt, ChainSpecProvider, ChangeSetReader, DatabaseProvider,
EvmEnvProvider, HeaderProvider, ReceiptProviderIdExt, RequestsProvider, StateProvider,
StateProviderBox, StateProviderFactory, StateReader, StateRootProvider, TransactionVariant,
TransactionsProvider, WithdrawalsProvider,
EvmEnvProvider, HeaderProvider, ReceiptProviderIdExt, StateProvider, StateProviderBox,
StateProviderFactory, StateReader, StateRootProvider, TransactionVariant, TransactionsProvider,
WithdrawalsProvider,
};
use alloy_consensus::constants::EMPTY_ROOT_HASH;
use alloy_eips::{BlockHashOrNumber, BlockId, BlockNumberOrTag};
@ -809,16 +809,6 @@ impl WithdrawalsProvider for MockEthProvider {
}
}
impl RequestsProvider for MockEthProvider {
fn requests_by_block(
&self,
_id: BlockHashOrNumber,
_timestamp: u64,
) -> ProviderResult<Option<reth_primitives::Requests>> {
Ok(None)
}
}
impl ChangeSetReader for MockEthProvider {
fn account_block_changeset(
&self,

12
crates/storage/provider/src/test_utils/noop.rs
View File

@ -37,7 +37,7 @@ use crate::{
traits::{BlockSource, ReceiptProvider},
AccountReader, BlockHashReader, BlockIdReader, BlockNumReader, BlockReader, BlockReaderIdExt,
ChainSpecProvider, ChangeSetReader, EvmEnvProvider, HeaderProvider, PruneCheckpointReader,
ReceiptProviderIdExt, RequestsProvider, StageCheckpointReader, StateProvider, StateProviderBox,
ReceiptProviderIdExt, StageCheckpointReader, StateProvider, StateProviderBox,
StateProviderFactory, StateRootProvider, StaticFileProviderFactory, TransactionVariant,
TransactionsProvider, WithdrawalsProvider,
};
@ -539,16 +539,6 @@ impl WithdrawalsProvider for NoopProvider {
}
}
impl RequestsProvider for NoopProvider {
fn requests_by_block(
&self,
_id: BlockHashOrNumber,
_timestamp: u64,
) -> ProviderResult<Option<reth_primitives::Requests>> {
Ok(None)
}
}
impl PruneCheckpointReader for NoopProvider {
fn get_prune_checkpoint(
&self,

5
crates/storage/storage-api/src/block.rs
View File

@ -1,6 +1,6 @@
use crate::{
BlockNumReader, HeaderProvider, ReceiptProvider, ReceiptProviderIdExt, RequestsProvider,
TransactionVariant, TransactionsProvider, WithdrawalsProvider,
BlockNumReader, HeaderProvider, ReceiptProvider, ReceiptProviderIdExt, TransactionVariant,
TransactionsProvider, WithdrawalsProvider,
};
use alloy_eips::{BlockHashOrNumber, BlockId, BlockNumberOrTag};
use alloy_primitives::{BlockNumber, Sealable, B256};
@ -52,7 +52,6 @@ pub trait BlockReader:
+ HeaderProvider
+ TransactionsProvider
+ ReceiptProvider
+ RequestsProvider
+ WithdrawalsProvider
+ Send
+ Sync

3
crates/storage/storage-api/src/lib.rs
View File

@ -31,9 +31,6 @@ pub use prune_checkpoint::*;
mod receipts;
pub use receipts::*;
mod requests;
pub use requests::*;
mod stage_checkpoint;
pub use stage_checkpoint::*;

14
crates/storage/storage-api/src/requests.rs
View File

@ -1,14 +0,0 @@
use alloy_eips::BlockHashOrNumber;
use reth_primitives::Requests;
use reth_storage_errors::provider::ProviderResult;
/// Client trait for fetching EIP-7685 [Requests] for blocks.
#[auto_impl::auto_impl(&, Arc)]
pub trait RequestsProvider: Send + Sync {
/// Get withdrawals by block id.
fn requests_by_block(
&self,
id: BlockHashOrNumber,
timestamp: u64,
) -> ProviderResult<Option<Requests>>;
}