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

2
bin/reth-bench/src/bench/new_payload_fcu.rs
View File

@ -75,7 +75,7 @@ impl Command {
while let Some((block, head, safe, finalized)) = receiver.recv().await {
// just put gas used here
let gas_used = block.gas_used;
let block_number = block.header.number;
let block_number = block.number;
let versioned_hashes: Vec<B256> =
block.body().blob_versioned_hashes_iter().copied().collect();

27
crates/blockchain-tree/src/blockchain_tree.rs
View File

@ -1199,7 +1199,8 @@ where
durations_recorder.record_relative(MakeCanonicalAction::ClearTrieUpdatesForOtherChildren);
// Send notification about new canonical chain and return outcome of canonicalization.
let outcome = CanonicalOutcome::Committed { head: chain_notification.tip().header.clone() };
let outcome =
CanonicalOutcome::Committed { head: chain_notification.tip().sealed_header().clone() };
let _ = self.canon_state_notification_sender.send(chain_notification);
Ok(outcome)
}
@ -1434,8 +1435,8 @@ mod tests {
) {
// insert genesis to db.
genesis.header.set_block_number(10);
genesis.header.set_state_root(EMPTY_ROOT_HASH);
genesis.set_block_number(10);
genesis.set_state_root(EMPTY_ROOT_HASH);
let provider = factory.provider_rw().unwrap();
provider
@ -1669,7 +1670,7 @@ mod tests {
assert_eq!(
tree.make_canonical(fork_block.hash()).unwrap(),
CanonicalOutcome::Committed { head: fork_block.header.clone() }
CanonicalOutcome::Committed { head: fork_block.sealed_header().clone() }
);
assert_eq!(
@ -1679,7 +1680,7 @@ mod tests {
assert_eq!(
tree.make_canonical(canonical_block_1.hash()).unwrap(),
CanonicalOutcome::Committed { head: canonical_block_1.header.clone() }
CanonicalOutcome::Committed { head: canonical_block_1.sealed_header().clone() }
);
assert_eq!(
@ -1694,12 +1695,12 @@ mod tests {
assert_eq!(
tree.make_canonical(sidechain_block_1.hash()).unwrap(),
CanonicalOutcome::Committed { head: sidechain_block_1.header.clone() }
CanonicalOutcome::Committed { head: sidechain_block_1.sealed_header().clone() }
);
assert_eq!(
tree.make_canonical(canonical_block_1.hash()).unwrap(),
CanonicalOutcome::Committed { head: canonical_block_1.header.clone() }
CanonicalOutcome::Committed { head: canonical_block_1.sealed_header().clone() }
);
assert_eq!(
@ -1709,7 +1710,7 @@ mod tests {
assert_eq!(
tree.make_canonical(sidechain_block_2.hash()).unwrap(),
CanonicalOutcome::Committed { head: sidechain_block_2.header.clone() }
CanonicalOutcome::Committed { head: sidechain_block_2.sealed_header().clone() }
);
assert_eq!(
@ -1719,7 +1720,7 @@ mod tests {
assert_eq!(
tree.make_canonical(canonical_block_3.hash()).unwrap(),
CanonicalOutcome::Committed { head: canonical_block_3.header.clone() }
CanonicalOutcome::Committed { head: canonical_block_3.sealed_header().clone() }
);
}
@ -1841,7 +1842,7 @@ mod tests {
assert_eq!(
tree.make_canonical(block2.hash()).unwrap(),
CanonicalOutcome::Committed { head: block2.header.clone() }
CanonicalOutcome::Committed { head: block2.sealed_header().clone() }
);
assert_eq!(
@ -1854,7 +1855,7 @@ mod tests {
assert_eq!(
tree.make_canonical(block3.hash()).unwrap(),
CanonicalOutcome::Committed { head: block3.header.clone() }
CanonicalOutcome::Committed { head: block3.sealed_header().clone() }
);
assert_eq!(
@ -1876,7 +1877,7 @@ mod tests {
assert_eq!(
tree.make_canonical(block5.hash()).unwrap(),
CanonicalOutcome::Committed { head: block5.header.clone() }
CanonicalOutcome::Committed { head: block5.sealed_header().clone() }
);
let provider = tree.externals.provider_factory.provider().unwrap();
@ -2337,7 +2338,7 @@ mod tests {
assert_eq!(
tree.insert_block(block2b.clone(), BlockValidationKind::Exhaustive).unwrap(),
InsertPayloadOk::Inserted(BlockStatus::Disconnected {
head: block2.header.num_hash(),
head: block2.num_hash(),
missing_ancestor: block2b.parent_num_hash()
})
);

4
crates/blockchain-tree/src/shareable.rs
View File

@ -114,7 +114,7 @@ where
{
fn header_by_hash(&self, hash: BlockHash) -> Option<SealedHeader> {
trace!(target: "blockchain_tree", ?hash, "Returning header by hash");
self.tree.read().sidechain_block_by_hash(hash).map(|b| b.header.clone())
self.tree.read().sidechain_block_by_hash(hash).map(|b| b.sealed_header().clone())
}
fn block_by_hash(&self, block_hash: BlockHash) -> Option<SealedBlock> {
@ -128,7 +128,7 @@ where
}
fn buffered_header_by_hash(&self, block_hash: BlockHash) -> Option<SealedHeader> {
self.tree.read().get_buffered_block(&block_hash).map(|b| b.header.clone())
self.tree.read().get_buffered_block(&block_hash).map(|b| b.sealed_header().clone())
}
fn is_canonical(&self, hash: BlockHash) -> Result<bool, ProviderError> {

34
crates/blockchain-tree/src/state.rs
View File

@ -191,10 +191,10 @@ mod tests {
let mut block1 = block.clone();
let mut block2 = block;
block1.block.header.set_hash(block1_hash);
block1.block.header.set_block_number(9);
block2.block.header.set_hash(block2_hash);
block2.block.header.set_block_number(10);
block1.block.set_hash(block1_hash);
block1.block.set_block_number(9);
block2.block.set_hash(block2_hash);
block2.block.set_block_number(10);
let chain = AppendableChain::new(Chain::new(
[block1, block2],
@ -257,10 +257,10 @@ mod tests {
let mut block1: SealedBlockWithSenders = Default::default();
let mut block2: SealedBlockWithSenders = Default::default();
block1.block.header.set_hash(block1_hash);
block1.block.header.set_block_number(9);
block2.block.header.set_hash(block2_hash);
block2.block.header.set_block_number(10);
block1.block.set_hash(block1_hash);
block1.block.set_block_number(9);
block2.block.set_hash(block2_hash);
block2.block.set_block_number(10);
// Create an chain with these blocks
let chain = AppendableChain::new(Chain::new(
@ -299,10 +299,10 @@ mod tests {
let mut block1: SealedBlockWithSenders = Default::default();
let mut block2: SealedBlockWithSenders = Default::default();
block1.block.header.set_hash(block1_hash);
block1.block.header.set_block_number(9);
block2.block.header.set_hash(block2_hash);
block2.block.header.set_block_number(10);
block1.block.set_hash(block1_hash);
block1.block.set_block_number(9);
block2.block.set_hash(block2_hash);
block2.block.set_block_number(10);
// Create a chain with these blocks
let chain = AppendableChain::new(Chain::new(
@ -337,7 +337,7 @@ mod tests {
// Create a block with a random hash and add it to the buffer
let block_hash = B256::random();
let mut block: SealedBlockWithSenders = Default::default();
block.block.header.set_hash(block_hash);
block.block.set_hash(block_hash);
// Add the block to the buffered blocks in the TreeState
tree_state.buffered_blocks.insert_block(block.clone());
@ -366,9 +366,9 @@ mod tests {
let mut ancestor_block: SealedBlockWithSenders = Default::default();
let mut descendant_block: SealedBlockWithSenders = Default::default();
ancestor_block.block.header.set_hash(ancestor_hash);
descendant_block.block.header.set_hash(descendant_hash);
descendant_block.block.header.set_parent_hash(ancestor_hash);
ancestor_block.block.set_hash(ancestor_hash);
descendant_block.block.set_hash(descendant_hash);
descendant_block.block.set_parent_hash(ancestor_hash);
// Insert the blocks into the buffer
tree_state.buffered_blocks.insert_block(ancestor_block.clone());
@ -398,7 +398,7 @@ mod tests {
let receipt2 = Receipt::default();
let mut block: SealedBlockWithSenders = Default::default();
block.block.header.set_hash(block_hash);
block.block.set_hash(block_hash);
let receipts = vec![receipt1, receipt2];

14
crates/chain-state/src/in_memory.rs
View File

@ -18,7 +18,7 @@ use reth_primitives::{
use reth_primitives_traits::{Block, BlockBody as _, SignedTransaction};
use reth_storage_api::StateProviderBox;
use reth_trie::{updates::TrieUpdates, HashedPostState};
use std::{collections::BTreeMap, ops::Deref, sync::Arc, time::Instant};
use std::{collections::BTreeMap, sync::Arc, time::Instant};
use tokio::sync::{broadcast, watch};
/// Size of the broadcast channel used to notify canonical state events.
@ -181,9 +181,9 @@ impl<N: NodePrimitives> CanonicalInMemoryState<N> {
safe: Option<SealedHeader<N::BlockHeader>>,
) -> Self {
let in_memory_state = InMemoryState::new(blocks, numbers, pending);
let header = in_memory_state
.head_state()
.map_or_else(SealedHeader::default, |state| state.block_ref().block().deref().clone());
let header = in_memory_state.head_state().map_or_else(SealedHeader::default, |state| {
state.block_ref().block().sealed_header().clone()
});
let chain_info_tracker = ChainInfoTracker::new(header, finalized, safe);
let (canon_state_notification_sender, _) =
broadcast::channel(CANON_STATE_NOTIFICATION_CHANNEL_SIZE);
@ -229,7 +229,7 @@ impl<N: NodePrimitives> CanonicalInMemoryState<N> {
/// Returns the header corresponding to the given hash.
pub fn header_by_hash(&self, hash: B256) -> Option<SealedHeader<N::BlockHeader>> {
self.state_by_hash(hash).map(|block| block.block_ref().block.header.clone())
self.state_by_hash(hash).map(|block| block.block_ref().block.sealed_header().clone())
}
/// Clears all entries in the in memory state.
@ -462,7 +462,7 @@ impl<N: NodePrimitives> CanonicalInMemoryState<N> {
/// Returns the `SealedHeader` corresponding to the pending state.
pub fn pending_sealed_header(&self) -> Option<SealedHeader<N::BlockHeader>> {
self.pending_state().map(|h| h.block_ref().block().deref().clone())
self.pending_state().map(|h| h.block_ref().block().sealed_header().clone())
}
/// Returns the `Header` corresponding to the pending state.
@ -1321,7 +1321,7 @@ mod tests {
assert_eq!(state.pending_header().unwrap(), block2.block().header().clone());
// Check the pending sealed header
assert_eq!(state.pending_sealed_header().unwrap(), block2.block().header.clone());
assert_eq!(state.pending_sealed_header().unwrap(), block2.block().sealed_header().clone());
// Check the pending block with senders
assert_eq!(

12
crates/consensus/beacon/src/engine/mod.rs
View File

@ -1670,7 +1670,7 @@ where
self.latest_valid_hash_for_invalid_payload(block.parent_hash)?
};
// keep track of the invalid header
self.invalid_headers.insert(block.header.block_with_parent());
self.invalid_headers.insert(block.sealed_header().block_with_parent());
PayloadStatus::new(
PayloadStatusEnum::Invalid { validation_error: error.to_string() },
latest_valid_hash,
@ -1779,7 +1779,7 @@ where
let (block, err) = err.split();
warn!(target: "consensus::engine", invalid_number=?block.number, invalid_hash=?block.hash(), %err, "Marking block as invalid");
self.invalid_headers.insert(block.header.block_with_parent());
self.invalid_headers.insert(block.sealed_header().block_with_parent());
}
}
}
@ -2485,7 +2485,7 @@ mod tests {
..Default::default()
},
);
block1.header.set_difficulty(U256::from(1));
block1.set_difficulty(U256::from(1));
// a second pre-merge block
let mut block2 = random_block(
@ -2497,7 +2497,7 @@ mod tests {
..Default::default()
},
);
block2.header.set_difficulty(U256::from(1));
block2.set_difficulty(U256::from(1));
// a transition block
let mut block3 = random_block(
@ -2509,7 +2509,7 @@ mod tests {
..Default::default()
},
);
block3.header.set_difficulty(U256::from(1));
block3.set_difficulty(U256::from(1));
let (_static_dir, static_dir_path) = create_test_static_files_dir();
insert_blocks(
@ -2883,7 +2883,7 @@ mod tests {
async fn payload_pre_merge() {
let data = BlockchainTestData::default();
let mut block1 = data.blocks[0].0.block.clone();
block1.header.set_difficulty(
block1.set_difficulty(
MAINNET.fork(EthereumHardfork::Paris).ttd().unwrap() - U256::from(1),
);
block1 = block1.unseal::<reth_primitives::Block>().seal_slow();

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

@ -936,7 +936,7 @@ where
while current_canonical_number > current_number {
if let Some(block) = self.executed_block_by_hash(old_hash)? {
old_chain.push(block.clone());
old_hash = block.block.header.parent_hash();
old_hash = block.block.parent_hash();
current_canonical_number -= 1;
} else {
// This shouldn't happen as we're walking back the canonical chain
@ -952,7 +952,7 @@ where
// a common ancestor (fork block) is reached.
while old_hash != current_hash {
if let Some(block) = self.executed_block_by_hash(old_hash)? {
old_hash = block.block.header.parent_hash();
old_hash = block.block.parent_hash();
old_chain.push(block);
} else {
// This shouldn't happen as we're walking back the canonical chain
@ -1082,7 +1082,7 @@ where
// 2. ensure we can apply a new chain update for the head block
if let Some(chain_update) = self.on_new_head(state.head_block_hash)? {
let tip = chain_update.tip().header.clone();
let tip = chain_update.tip().sealed_header().clone();
self.on_canonical_chain_update(chain_update);
// update the safe and finalized blocks and ensure their values are valid
@ -1617,8 +1617,11 @@ where
hash: B256,
) -> ProviderResult<Option<SealedHeader<N::BlockHeader>>> {
// check memory first
let block =
self.state.tree_state.block_by_hash(hash).map(|block| block.as_ref().clone().header);
let block = self
.state
.tree_state
.block_by_hash(hash)
.map(|block| block.as_ref().sealed_header().clone());
if block.is_some() {
Ok(block)
@ -2031,7 +2034,7 @@ where
// update the tracked canonical head
self.state.tree_state.set_canonical_head(chain_update.tip().num_hash());
let tip = chain_update.tip().header.clone();
let tip = chain_update.tip().sealed_header().clone();
let notification = chain_update.to_chain_notification();
// reinsert any missing reorged blocks
@ -2543,7 +2546,7 @@ where
};
// keep track of the invalid header
self.state.invalid_headers.insert(block.header.block_with_parent());
self.state.invalid_headers.insert(block.block_with_parent());
Ok(PayloadStatus::new(
PayloadStatusEnum::Invalid { validation_error: validation_err.to_string() },
latest_valid_hash,

2
crates/ethereum/payload/src/lib.rs
View File

@ -490,7 +490,7 @@ where
};
let sealed_block = Arc::new(block.seal_slow());
debug!(target: "payload_builder", id=%attributes.id, sealed_block_header = ?sealed_block.header, "sealed built block");
debug!(target: "payload_builder", id=%attributes.id, sealed_block_header = ?sealed_block.sealed_header(), "sealed built block");
// create the executed block data
let executed = ExecutedBlock {

6
crates/evm/execution-types/src/chain.rs
View File

@ -91,7 +91,7 @@ impl<N: NodePrimitives> Chain<N> {
/// Returns an iterator over all headers in the block with increasing block numbers.
pub fn headers(&self) -> impl Iterator<Item = SealedHeader<N::BlockHeader>> + '_ {
self.blocks.values().map(|block| block.header.clone())
self.blocks.values().map(|block| block.sealed_header().clone())
}
/// Get cached trie updates for this chain.
@ -858,8 +858,8 @@ mod tests {
let mut block2 = block;
// Set the hashes of block1 and block2
block1.block.header.set_hash(block1_hash);
block2.block.header.set_hash(block2_hash);
block1.block.set_hash(block1_hash);
block2.block.set_hash(block2_hash);
// Create a random receipt object, receipt1
let receipt1 = Receipt {

32
crates/exex/exex/src/manager.rs
View File

@ -767,8 +767,8 @@ mod tests {
// Define the notification for testing
let mut block1: SealedBlockWithSenders = Default::default();
block1.block.header.set_hash(B256::new([0x01; 32]));
block1.block.header.set_block_number(10);
block1.block.set_hash(B256::new([0x01; 32]));
block1.block.set_block_number(10);
let notification1 = ExExNotification::ChainCommitted {
new: Arc::new(Chain::new(vec![block1.clone()], Default::default(), Default::default())),
@ -785,8 +785,8 @@ mod tests {
// Push another notification
let mut block2: SealedBlockWithSenders = Default::default();
block2.block.header.set_hash(B256::new([0x02; 32]));
block2.block.header.set_block_number(20);
block2.block.set_hash(B256::new([0x02; 32]));
block2.block.set_block_number(20);
let notification2 = ExExNotification::ChainCommitted {
new: Arc::new(Chain::new(vec![block2.clone()], Default::default(), Default::default())),
@ -828,8 +828,8 @@ mod tests {
// Push some notifications to fill part of the buffer
let mut block1: SealedBlockWithSenders = Default::default();
block1.block.header.set_hash(B256::new([0x01; 32]));
block1.block.header.set_block_number(10);
block1.set_hash(B256::new([0x01; 32]));
block1.set_block_number(10);
let notification1 = ExExNotification::ChainCommitted {
new: Arc::new(Chain::new(vec![block1.clone()], Default::default(), Default::default())),
@ -1117,12 +1117,12 @@ mod tests {
// Setup two blocks for the chain commit notification
let mut block1: SealedBlockWithSenders = Default::default();
block1.block.header.set_hash(B256::new([0x01; 32]));
block1.block.header.set_block_number(10);
block1.block.set_hash(B256::new([0x01; 32]));
block1.block.set_block_number(10);
let mut block2: SealedBlockWithSenders = Default::default();
block2.block.header.set_hash(B256::new([0x02; 32]));
block2.block.header.set_block_number(11);
block2.block.set_hash(B256::new([0x02; 32]));
block2.block.set_block_number(11);
// Setup a notification
let notification = ExExNotification::ChainCommitted {
@ -1170,8 +1170,8 @@ mod tests {
exex_handle.finished_height = Some(BlockNumHash::new(15, B256::random()));
let mut block1: SealedBlockWithSenders = Default::default();
block1.block.header.set_hash(B256::new([0x01; 32]));
block1.block.header.set_block_number(10);
block1.block.set_hash(B256::new([0x01; 32]));
block1.block.set_block_number(10);
let notification = ExExNotification::ChainCommitted {
new: Arc::new(Chain::new(vec![block1.clone()], Default::default(), Default::default())),
@ -1327,7 +1327,7 @@ mod tests {
};
let (finalized_headers_tx, rx) = watch::channel(None);
finalized_headers_tx.send(Some(genesis_block.header.clone()))?;
finalized_headers_tx.send(Some(genesis_block.sealed_header().clone()))?;
let finalized_header_stream = ForkChoiceStream::new(rx);
let mut exex_manager = std::pin::pin!(ExExManager::new(
@ -1361,7 +1361,7 @@ mod tests {
[notification.clone()]
);
finalized_headers_tx.send(Some(block.header.clone()))?;
finalized_headers_tx.send(Some(block.sealed_header().clone()))?;
assert!(exex_manager.as_mut().poll(&mut cx).is_pending());
// WAL isn't finalized because the ExEx didn't emit the `FinishedHeight` event
assert_eq!(
@ -1374,7 +1374,7 @@ mod tests {
.send(ExExEvent::FinishedHeight((rng.gen::<u64>(), rng.gen::<B256>()).into()))
.unwrap();
finalized_headers_tx.send(Some(block.header.clone()))?;
finalized_headers_tx.send(Some(block.sealed_header().clone()))?;
assert!(exex_manager.as_mut().poll(&mut cx).is_pending());
// WAL isn't finalized because the ExEx emitted a `FinishedHeight` event with a
// non-canonical block
@ -1386,7 +1386,7 @@ mod tests {
// Send a `FinishedHeight` event with a canonical block
events_tx.send(ExExEvent::FinishedHeight(block.num_hash())).unwrap();
finalized_headers_tx.send(Some(block.header.clone()))?;
finalized_headers_tx.send(Some(block.sealed_header().clone()))?;
assert!(exex_manager.as_mut().poll(&mut cx).is_pending());
// WAL is finalized
assert_eq!(exex_manager.wal.iter_notifications()?.next().transpose()?, None);

2
crates/net/downloaders/src/bodies/bodies.rs
View File

@ -677,7 +677,7 @@ mod tests {
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 1..2, ..Default::default() },
);
let headers = blocks.iter().map(|block| block.header.clone()).collect::<Vec<_>>();
let headers = blocks.iter().map(|block| block.sealed_header().clone()).collect::<Vec<_>>();
let bodies = blocks
.into_iter()
.map(|block| (block.hash(), block.into_body()))

2
crates/net/downloaders/src/bodies/request.rs
View File

@ -194,7 +194,7 @@ where
// Body is invalid, put the header back and return an error
let hash = block.hash();
let number = block.number();
self.pending_headers.push_front(block.header);
self.pending_headers.push_front(block.into_sealed_header());
return Err(DownloadError::BodyValidation {
hash,
number,

2
crates/net/downloaders/src/test_utils/mod.rs
View File

@ -28,7 +28,7 @@ pub(crate) fn generate_bodies(
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..2, ..Default::default() },
);
let headers = blocks.iter().map(|block| block.header.clone()).collect();
let headers = blocks.iter().map(|block| block.sealed_header().clone()).collect();
let bodies = blocks.into_iter().map(|block| (block.hash(), block.into_body())).collect();
(headers, bodies)

3
crates/net/p2p/src/bodies/response.rs
View File

@ -2,7 +2,6 @@ use alloy_consensus::BlockHeader;
use alloy_primitives::{BlockNumber, U256};
use reth_primitives::{BlockBody, SealedBlock, SealedHeader};
use reth_primitives_traits::InMemorySize;
/// The block response
#[derive(PartialEq, Eq, Debug, Clone)]
pub enum BlockResponse<H, B = BlockBody> {
@ -19,7 +18,7 @@ where
/// Return the reference to the response header
pub const fn header(&self) -> &SealedHeader<H> {
match self {
Self::Full(block) => &block.header,
Self::Full(block) => block.sealed_header(),
Self::Empty(header) => header,
}
}

12
crates/node/events/src/node.rs
View File

@ -255,12 +255,12 @@ impl NodeState {
hash=?block.hash(),
peers=self.num_connected_peers(),
txs=block.body().transactions().len(),
gas=%format_gas(block.header.gas_used()),
gas_throughput=%format_gas_throughput(block.header.gas_used(), elapsed),
full=%format!("{:.1}%", block.header.gas_used() as f64 * 100.0 / block.header.gas_limit() as f64),
base_fee=%format!("{:.2}gwei", block.header.base_fee_per_gas().unwrap_or(0) as f64 / GWEI_TO_WEI as f64),
blobs=block.header.blob_gas_used().unwrap_or(0) / alloy_eips::eip4844::DATA_GAS_PER_BLOB,
excess_blobs=block.header.excess_blob_gas().unwrap_or(0) / alloy_eips::eip4844::DATA_GAS_PER_BLOB,
gas=%format_gas(block.gas_used()),
gas_throughput=%format_gas_throughput(block.gas_used(), elapsed),
full=%format!("{:.1}%", block.gas_used() as f64 * 100.0 / block.gas_limit() as f64),
base_fee=%format!("{:.2}gwei", block.base_fee_per_gas().unwrap_or(0) as f64 / GWEI_TO_WEI as f64),
blobs=block.blob_gas_used().unwrap_or(0) / alloy_eips::eip4844::DATA_GAS_PER_BLOB,
excess_blobs=block.excess_blob_gas().unwrap_or(0) / alloy_eips::eip4844::DATA_GAS_PER_BLOB,
?elapsed,
"Block added to canonical chain"
);

2
crates/optimism/payload/src/builder.rs
View File

@ -434,7 +434,7 @@ where
};
let sealed_block = Arc::new(block.seal_slow());
debug!(target: "payload_builder", id=%ctx.attributes().payload_id(), sealed_block_header = ?sealed_block.header, "sealed built block");
debug!(target: "payload_builder", id=%ctx.attributes().payload_id(), sealed_block_header = ?sealed_block.header(), "sealed built block");
// create the executed block data
let executed: ExecutedBlock<OpPrimitives> = ExecutedBlock {

12
crates/primitives/src/block.rs
View File

@ -167,7 +167,7 @@ pub struct SealedBlock<H = Header, B = BlockBody> {
/// Locked block header.
#[deref]
#[deref_mut]
pub header: SealedHeader<H>,
header: SealedHeader<H>,
/// Block body.
body: B,
}
@ -190,6 +190,16 @@ impl<H, B> SealedBlock<H, B> {
&self.body
}
/// Returns the Sealed header.
pub const fn sealed_header(&self) -> &SealedHeader<H> {
&self.header
}
/// Consumes the block and returns the sealed header.
pub fn into_sealed_header(self) -> SealedHeader<H> {
self.header
}
/// Consumes the block and returns the header.
pub fn into_header(self) -> H {
self.header.unseal()

5
crates/rpc/rpc-eth-api/src/helpers/call.rs
View File

@ -126,10 +126,7 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
base_fee_params,
)
} else {
base_block
.header
.next_block_base_fee(base_fee_params)
.unwrap_or_default()
base_block.next_block_base_fee(base_fee_params).unwrap_or_default()
};
block_env.basefee = U256::from(base_fee);
} else {

4
crates/rpc/rpc-eth-api/src/helpers/trace.rs
View File

@ -496,12 +496,12 @@ pub trait Trace:
db,
cfg,
block_env,
block.header.parent_beacon_block_root(),
block.parent_beacon_block_root(),
)
.map_err(|_| EthApiError::EvmCustom("failed to apply 4788 system call".to_string()))?;
system_caller
.pre_block_blockhashes_contract_call(db, cfg, block_env, block.header.parent_hash())
.pre_block_blockhashes_contract_call(db, cfg, block_env, block.parent_hash())
.map_err(|_| {
EthApiError::EvmCustom("failed to apply blockhashes system call".to_string())
})?;

10
crates/rpc/rpc/src/trace.rs
View File

@ -314,7 +314,7 @@ where
if let Some(base_block_reward) = self.calculate_base_block_reward(block.header())? {
all_traces.extend(
self.extract_reward_traces(
block.header.header(),
block.header(),
block.body().ommers(),
base_block_reward,
)
@ -391,11 +391,9 @@ where
maybe_traces.map(|traces| traces.into_iter().flatten().collect::<Vec<_>>());
if let (Some(block), Some(traces)) = (maybe_block, maybe_traces.as_mut()) {
if let Some(base_block_reward) =
self.calculate_base_block_reward(block.header.header())?
{
if let Some(base_block_reward) = self.calculate_base_block_reward(block.header())? {
traces.extend(self.extract_reward_traces(
block.block.header(),
block.header(),
block.body().ommers(),
base_block_reward,
));
@ -490,7 +488,7 @@ where
Ok(Some(BlockOpcodeGas {
block_hash: block.hash(),
block_number: block.header.number(),
block_number: block.number(),
transactions,
}))
}

15
crates/rpc/rpc/src/validation.rs
View File

@ -102,10 +102,10 @@ where
message: BidTrace,
registered_gas_limit: u64,
) -> Result<(), ValidationApiError> {
self.validate_message_against_header(&block.header, &message)?;
self.validate_message_against_header(block.sealed_header(), &message)?;
self.consensus.validate_header_with_total_difficulty(&block.header, U256::MAX)?;
self.consensus.validate_header(&block.header)?;
self.consensus.validate_header_with_total_difficulty(block.sealed_header(), U256::MAX)?;
self.consensus.validate_header(block.sealed_header())?;
self.consensus.validate_block_pre_execution(&block)?;
if !self.disallow.is_empty() {
@ -130,15 +130,14 @@ where
let latest_header =
self.provider.latest_header()?.ok_or_else(|| ValidationApiError::MissingLatestBlock)?;
if latest_header.hash() != block.header.parent_hash() {
if latest_header.hash() != block.parent_hash() {
return Err(ConsensusError::ParentHashMismatch(
GotExpected { got: block.header.parent_hash(), expected: latest_header.hash() }
.into(),
GotExpected { got: block.parent_hash(), expected: latest_header.hash() }.into(),
)
.into())
}
self.consensus.validate_header_against_parent(&block.header, &latest_header)?;
self.validate_gas_limit(registered_gas_limit, &latest_header, &block.header)?;
self.consensus.validate_header_against_parent(block.sealed_header(), &latest_header)?;
self.validate_gas_limit(registered_gas_limit, &latest_header, block.sealed_header())?;
let latest_header_hash = latest_header.hash();
let state_provider = self.provider.state_by_block_hash(latest_header_hash)?;

4
crates/stages/stages/benches/setup/mod.rs
View File

@ -151,7 +151,7 @@ pub(crate) fn txs_testdata(num_blocks: u64) -> TestStageDB {
.unwrap();
let second_block = blocks.get_mut(1).unwrap();
let cloned_second = second_block.clone();
let mut updated_header = cloned_second.header.clone().unseal();
let mut updated_header = cloned_second.header().clone();
updated_header.state_root = root;
*second_block =
SealedBlock::new(SealedHeader::seal(updated_header), cloned_second.into_body());
@ -185,7 +185,7 @@ pub(crate) fn txs_testdata(num_blocks: u64) -> TestStageDB {
let last_block = blocks.last_mut().unwrap();
let cloned_last = last_block.clone();
let mut updated_header = cloned_last.header.clone().unseal();
let mut updated_header = cloned_last.header().clone();
updated_header.state_root = root;
*last_block = SealedBlock::new(SealedHeader::seal(updated_header), cloned_last.into_body());

2
crates/stages/stages/src/stages/bodies.rs
View File

@ -582,7 +582,7 @@ mod tests {
..Default::default()
},
);
self.db.insert_headers_with_td(blocks.iter().map(|block| &block.header))?;
self.db.insert_headers_with_td(blocks.iter().map(|block| block.sealed_header()))?;
if let Some(progress) = blocks.get(start as usize) {
// Insert last progress data
{

6
crates/stages/stages/src/stages/hashing_storage.rs
View File

@ -344,7 +344,7 @@ mod tests {
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..3, ..Default::default() },
);
self.db.insert_headers(blocks.iter().map(|block| &block.header))?;
self.db.insert_headers(blocks.iter().map(|block| block.sealed_header()))?;
let iter = blocks.iter();
let mut next_tx_num = 0;
@ -373,7 +373,7 @@ mod tests {
tx,
(block_number, *addr).into(),
new_entry,
progress.header.number == stage_progress,
progress.number == stage_progress,
)?;
}
@ -392,7 +392,7 @@ mod tests {
key: keccak256("mining"),
value: U256::from(rng.gen::<u32>()),
},
progress.header.number == stage_progress,
progress.number == stage_progress,
)?;
}

2
crates/stages/stages/src/test_utils/test_db.rs
View File

@ -235,7 +235,7 @@ impl TestStageDB {
.then(|| provider.latest_writer(StaticFileSegment::Headers).unwrap());
blocks.iter().try_for_each(|block| {
Self::insert_header(headers_writer.as_mut(), &tx, &block.header, U256::ZERO)
Self::insert_header(headers_writer.as_mut(), &tx, block.sealed_header(), U256::ZERO)
})?;
if let Some(mut writer) = headers_writer {

2
crates/static-file/static-file/src/static_file_producer.rs
View File

@ -292,7 +292,7 @@ mod tests {
let tx = db.factory.db_ref().tx_mut().expect("init tx");
for block in &blocks {
TestStageDB::insert_header(None, &tx, &block.header, U256::ZERO)
TestStageDB::insert_header(None, &tx, block.sealed_header(), U256::ZERO)
.expect("insert block header");
}
tx.commit().expect("commit tx");

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)]);