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: make SealedBlock.header field private (#13646)

Browse Source 
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
This commit is contained in:
DevOrbitlabs
2025-01-08 02:44:39 +07:00
committed by GitHub
parent 3e980e61d8
commit 35392bd8e9
30 changed files with 169 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -810,7 +810,7 @@ mod tests {
};
use revm::db::BundleState;
use std::{
ops::{Bound, Range, RangeBounds},
ops::{Bound, Deref, Range, RangeBounds},
sync::Arc,
time::Instant,
};
@ -948,9 +948,9 @@ mod tests {
let finalized_block = blocks.get(block_count - 3).unwrap();
// Set the canonical head, safe, and finalized blocks
provider.set_canonical_head(canonical_block.header.clone());
provider.set_safe(safe_block.header.clone());
provider.set_finalized(finalized_block.header.clone());
provider.set_canonical_head(canonical_block.sealed_header().clone());
provider.set_safe(safe_block.sealed_header().clone());
provider.set_finalized(finalized_block.sealed_header().clone());
Ok((provider, database_blocks.clone(), in_memory_blocks.clone(), receipts))
}
@ -1357,7 +1357,7 @@ mod tests {
let in_memory_block = in_memory_blocks.last().unwrap().clone();
// make sure that the finalized block is on db
let finalized_block = database_blocks.get(database_blocks.len() - 3).unwrap();
provider.set_finalized(finalized_block.header.clone());
provider.set_finalized(finalized_block.sealed_header().clone());
let blocks = [database_blocks, in_memory_blocks].concat();
@ -1376,7 +1376,7 @@ mod tests {
blocks
.iter()
.take_while(|header| header.number <= 8)
.map(|b| b.header.clone())
.map(|b| b.sealed_header().clone())
.collect::<Vec<_>>()
);
@ -1548,38 +1548,38 @@ mod tests {
let block_number = database_block.number;
assert_eq!(
provider.header_by_number_or_tag(block_number.into()).unwrap(),
Some(database_block.header.clone().unseal())
Some(database_block.header().clone())
);
assert_eq!(
provider.sealed_header_by_number_or_tag(block_number.into()).unwrap(),
Some(database_block.header)
provider.sealed_header_by_number_or_tag(block_number.into())?,
Some(database_block.sealed_header().clone())
);
assert_eq!(
provider.header_by_number_or_tag(BlockNumberOrTag::Latest).unwrap(),
Some(canonical_block.header.clone().unseal())
Some(canonical_block.header().clone())
);
assert_eq!(
provider.sealed_header_by_number_or_tag(BlockNumberOrTag::Latest).unwrap(),
Some(canonical_block.header)
Some(canonical_block.sealed_header().clone())
);
assert_eq!(
provider.header_by_number_or_tag(BlockNumberOrTag::Safe).unwrap(),
Some(safe_block.header.clone().unseal())
Some(safe_block.header().clone())
);
assert_eq!(
provider.sealed_header_by_number_or_tag(BlockNumberOrTag::Safe).unwrap(),
Some(safe_block.header)
Some(safe_block.sealed_header().clone())
);
assert_eq!(
provider.header_by_number_or_tag(BlockNumberOrTag::Finalized).unwrap(),
Some(finalized_block.header.clone().unseal())
Some(finalized_block.header().clone())
);
assert_eq!(
provider.sealed_header_by_number_or_tag(BlockNumberOrTag::Finalized).unwrap(),
Some(finalized_block.header)
Some(finalized_block.sealed_header().clone())
);
Ok(())
@ -1603,20 +1603,20 @@ mod tests {
assert_eq!(
provider.header_by_id(block_number.into()).unwrap(),
Some(database_block.header.clone().unseal())
Some(database_block.header().clone())
);
assert_eq!(
provider.sealed_header_by_id(block_number.into()).unwrap(),
Some(database_block.header.clone())
Some(database_block.sealed_header().clone())
);
assert_eq!(
provider.header_by_id(block_hash.into()).unwrap(),
Some(database_block.header.clone().unseal())
Some(database_block.header().clone())
);
assert_eq!(
provider.sealed_header_by_id(block_hash.into()).unwrap(),
Some(database_block.header)
Some(database_block.sealed_header().clone())
);
let block_number = in_memory_block.number;
@ -1624,20 +1624,20 @@ mod tests {
assert_eq!(
provider.header_by_id(block_number.into()).unwrap(),
Some(in_memory_block.header.clone().unseal())
Some(in_memory_block.header().clone())
);
assert_eq!(
provider.sealed_header_by_id(block_number.into()).unwrap(),
Some(in_memory_block.header.clone())
Some(in_memory_block.sealed_header().clone())
);
assert_eq!(
provider.header_by_id(block_hash.into()).unwrap(),
Some(in_memory_block.header.clone().unseal())
Some(in_memory_block.header().clone())
);
assert_eq!(
provider.sealed_header_by_id(block_hash.into()).unwrap(),
Some(in_memory_block.header)
Some(in_memory_block.sealed_header().clone())
);
Ok(())
@ -2023,7 +2023,7 @@ mod tests {
);
// test state by block tag for safe block
let safe_block = in_memory_blocks[in_memory_blocks.len() - 2].clone();
in_memory_provider.canonical_in_memory_state.set_safe(safe_block.header.clone());
in_memory_provider.canonical_in_memory_state.set_safe(safe_block.sealed_header().clone());
assert_eq!(
safe_block.hash(),
in_memory_provider
@ -2033,7 +2033,9 @@ mod tests {
);
// test state by block tag for finalized block
let finalized_block = in_memory_blocks[in_memory_blocks.len() - 3].clone();
in_memory_provider.canonical_in_memory_state.set_finalized(finalized_block.header.clone());
in_memory_provider
.canonical_in_memory_state
.set_finalized(finalized_block.sealed_header().clone());
assert_eq!(
finalized_block.hash(),
in_memory_provider
@ -2106,11 +2108,11 @@ mod tests {
// Set the safe block in memory
let safe_block = in_memory_blocks[in_memory_blocks.len() - 2].clone();
provider.canonical_in_memory_state.set_safe(safe_block.header.clone());
provider.canonical_in_memory_state.set_safe(safe_block.sealed_header().clone());
// Set the finalized block in memory
let finalized_block = in_memory_blocks[in_memory_blocks.len() - 3].clone();
provider.canonical_in_memory_state.set_finalized(finalized_block.header.clone());
provider.canonical_in_memory_state.set_finalized(finalized_block.sealed_header().clone());
// Verify the pending block number and hash
assert_eq!(
@ -2325,7 +2327,7 @@ mod tests {
// instead start end
test_by_block_range!([
(headers_range, |block: &SealedBlock| block.header().clone()),
(sealed_headers_range, |block: &SealedBlock| block.header.clone()),
(sealed_headers_range, |block: &SealedBlock| block.sealed_header().clone()),
(block_range, |block: &SealedBlock| block.clone().unseal()),
(block_with_senders_range, |block: &SealedBlock| block
.clone()
@ -2458,7 +2460,7 @@ mod tests {
header_by_number,
|block: &SealedBlock, _: TxNumber, _: B256, _: &Vec<Vec<Receipt>>| (
block.number,
Some(block.header.header().clone())
Some(block.header().clone())
),
u64::MAX
),
@ -2467,7 +2469,7 @@ mod tests {
sealed_header,
|block: &SealedBlock, _: TxNumber, _: B256, _: &Vec<Vec<Receipt>>| (
block.number,
Some(block.header.clone())
Some(block.sealed_header().clone())
),
u64::MAX
),

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

@ -631,7 +631,7 @@ impl<N: ProviderNodeTypes> HeaderProvider for ConsistentProvider<N> {
self.get_in_memory_or_storage_by_block(
(*block_hash).into(),
|db_provider| db_provider.header(block_hash),
|block_state| Ok(Some(block_state.block_ref().block().header.header().clone())),
|block_state| Ok(Some(block_state.block_ref().block().header().clone())),
)
}
@ -639,7 +639,7 @@ impl<N: ProviderNodeTypes> HeaderProvider for ConsistentProvider<N> {
self.get_in_memory_or_storage_by_block(
num.into(),
|db_provider| db_provider.header_by_number(num),
|block_state| Ok(Some(block_state.block_ref().block().header.header().clone())),
|block_state| Ok(Some(block_state.block_ref().block().header().clone())),
)
}
@ -681,7 +681,7 @@ impl<N: ProviderNodeTypes> HeaderProvider for ConsistentProvider<N> {
self.get_in_memory_or_storage_by_block_range_while(
range,
|db_provider, range, _| db_provider.headers_range(range),
|block_state, _| Some(block_state.block_ref().block().header.header().clone()),
|block_state, _| Some(block_state.block_ref().block().header().clone()),
|_| true,
)
}
@ -693,7 +693,7 @@ impl<N: ProviderNodeTypes> HeaderProvider for ConsistentProvider<N> {
self.get_in_memory_or_storage_by_block(
number.into(),
|db_provider| db_provider.sealed_header(number),
|block_state| Ok(Some(block_state.block_ref().block().header.clone())),
|block_state| Ok(Some(block_state.block_ref().block().sealed_header().clone())),
)
}
@ -704,7 +704,7 @@ impl<N: ProviderNodeTypes> HeaderProvider for ConsistentProvider<N> {
self.get_in_memory_or_storage_by_block_range_while(
range,
|db_provider, range, _| db_provider.sealed_headers_range(range),
|block_state, _| Some(block_state.block_ref().block().header.clone()),
|block_state, _| Some(block_state.block_ref().block().sealed_header().clone()),
|_| true,
)
}
@ -718,7 +718,7 @@ impl<N: ProviderNodeTypes> HeaderProvider for ConsistentProvider<N> {
range,
|db_provider, range, predicate| db_provider.sealed_headers_while(range, predicate),
|block_state, predicate| {
let header = &block_state.block_ref().block().header;
let header = block_state.block_ref().block().sealed_header();
predicate(header).then(|| header.clone())
},
predicate,

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

@ -426,12 +426,12 @@ impl<
&self,
block: SealedBlockWithSenders<<Self as BlockWriter>::Block>,
) -> ProviderResult<StoredBlockBodyIndices> {
let ttd = if block.number == 0 {
block.difficulty
let ttd = if block.number() == 0 {
block.difficulty()
} else {
let parent_block_number = block.number - 1;
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.difficulty()
};
let mut writer = self.static_file_provider.latest_writer(StaticFileSegment::Headers)?;
@ -439,14 +439,14 @@ impl<
// Backfill: some tests start at a forward block number, but static files require no gaps.
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.header.clone().unseal();
for block_number in 0..block.number() {
let mut prev = block.sealed_header().clone().unseal();
prev.number = block_number;
writer.append_header(&prev, U256::ZERO, &B256::ZERO)?;
}
}
writer.append_header(block.header.as_ref(), ttd, &block.hash())?;
writer.append_header(block.header(), ttd, &block.hash())?;
self.insert_block(block, StorageLocation::Database)
}
@ -2769,8 +2769,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
durations_recorder.record_relative(metrics::Action::InsertCanonicalHeaders);
// Put header with canonical hashes.
self.tx
.put::<tables::Headers<HeaderTy<N>>>(block_number, block.header.as_ref().clone())?;
self.tx.put::<tables::Headers<HeaderTy<N>>>(block_number, block.header().clone())?;
durations_recorder.record_relative(metrics::Action::InsertHeaders);
self.tx.put::<tables::HeaderTerminalDifficulties>(block_number, ttd.into())?;
@ -2780,7 +2779,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
if write_to.static_files() {
let mut writer =
self.static_file_provider.get_writer(block_number, StaticFileSegment::Headers)?;
writer.append_header(&block.header, ttd, &block.hash())?;
writer.append_header(block.header(), ttd, &block.hash())?;
}
self.tx.put::<tables::HeaderNumbers>(block.hash(), block_number)?;

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

@ -29,7 +29,7 @@ pub fn assert_genesis_block<DB: Database, N: NodeTypes>(
let tx = provider;
// check if all tables are empty
assert_eq!(tx.table::<tables::Headers>().unwrap(), vec![(g.number, g.header.clone().unseal())]);
assert_eq!(tx.table::<tables::Headers>().unwrap(), vec![(g.number, g.header().clone())]);
assert_eq!(tx.table::<tables::HeaderNumbers>().unwrap(), vec![(h, n)]);
assert_eq!(tx.table::<tables::CanonicalHeaders>().unwrap(), vec![(n, h)]);