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

renamed OptimismHardfork to OpHardfork (#12410)

Browse Source
This commit is contained in:
Steven
2024-11-08 12:29:34 -06:00
committed by GitHub
parent fc484b793f
commit 5cfe9a9879
13 changed files with 146 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
crates/optimism/chainspec/src/base.rs
View File

@ -6,7 +6,7 @@ use alloy_chains::Chain;
use alloy_primitives::{b256, U256};
use reth_chainspec::{once_cell_set, BaseFeeParams, BaseFeeParamsKind, ChainSpec};
use reth_ethereum_forks::EthereumHardfork;
use reth_optimism_forks::OptimismHardfork;
use reth_optimism_forks::OpHardfork;
use crate::{LazyLock, OpChainSpec};
@ -21,11 +21,11 @@ pub static BASE_MAINNET: LazyLock<Arc<OpChainSpec>> = LazyLock::new(|| {
"f712aa9241cc24369b143cf6dce85f0902a9731e70d66818a3a5845b296c73dd"
)),
paris_block_and_final_difficulty: Some((0, U256::from(0))),
hardforks: OptimismHardfork::base_mainnet(),
hardforks: OpHardfork::base_mainnet(),
base_fee_params: BaseFeeParamsKind::Variable(
vec![
(EthereumHardfork::London.boxed(), BaseFeeParams::optimism()),
(OptimismHardfork::Canyon.boxed(), BaseFeeParams::optimism_canyon()),
(OpHardfork::Canyon.boxed(), BaseFeeParams::optimism_canyon()),
]
.into(),
),

6
crates/optimism/chainspec/src/base_sepolia.rs
View File

@ -6,7 +6,7 @@ use alloy_chains::Chain;
use alloy_primitives::{b256, U256};
use reth_chainspec::{once_cell_set, BaseFeeParams, BaseFeeParamsKind, ChainSpec};
use reth_ethereum_forks::EthereumHardfork;
use reth_optimism_forks::OptimismHardfork;
use reth_optimism_forks::OpHardfork;
use crate::{LazyLock, OpChainSpec};
@ -21,11 +21,11 @@ pub static BASE_SEPOLIA: LazyLock<Arc<OpChainSpec>> = LazyLock::new(|| {
"0dcc9e089e30b90ddfc55be9a37dd15bc551aeee999d2e2b51414c54eaf934e4"
)),
paris_block_and_final_difficulty: Some((0, U256::from(0))),
hardforks: OptimismHardfork::base_sepolia(),
hardforks: OpHardfork::base_sepolia(),
base_fee_params: BaseFeeParamsKind::Variable(
vec![
(EthereumHardfork::London.boxed(), BaseFeeParams::base_sepolia()),
(OptimismHardfork::Canyon.boxed(), BaseFeeParams::base_sepolia_canyon()),
(OpHardfork::Canyon.boxed(), BaseFeeParams::base_sepolia_canyon()),
]
.into(),
),

128
crates/optimism/chainspec/src/lib.rs
View File

@ -96,7 +96,7 @@ impl OpChainSpecBuilder {
}
/// Remove the given fork from the spec.
pub fn without_fork(mut self, fork: reth_optimism_forks::OptimismHardfork) -> Self {
pub fn without_fork(mut self, fork: reth_optimism_forks::OpHardfork) -> Self {
self.inner = self.inner.without_fork(fork);
self
}
@ -104,19 +104,17 @@ impl OpChainSpecBuilder {
/// Enable Bedrock at genesis
pub fn bedrock_activated(mut self) -> Self {
self.inner = self.inner.paris_activated();
self.inner = self
.inner
.with_fork(reth_optimism_forks::OptimismHardfork::Bedrock, ForkCondition::Block(0));
self.inner =
self.inner.with_fork(reth_optimism_forks::OpHardfork::Bedrock, ForkCondition::Block(0));
self
}
/// Enable Regolith at genesis
pub fn regolith_activated(mut self) -> Self {
self = self.bedrock_activated();
self.inner = self.inner.with_fork(
reth_optimism_forks::OptimismHardfork::Regolith,
ForkCondition::Timestamp(0),
);
self.inner = self
.inner
.with_fork(reth_optimism_forks::OpHardfork::Regolith, ForkCondition::Timestamp(0));
self
}
@ -127,7 +125,7 @@ impl OpChainSpecBuilder {
self.inner = self.inner.with_fork(EthereumHardfork::Shanghai, ForkCondition::Timestamp(0));
self.inner = self
.inner
.with_fork(reth_optimism_forks::OptimismHardfork::Canyon, ForkCondition::Timestamp(0));
.with_fork(reth_optimism_forks::OpHardfork::Canyon, ForkCondition::Timestamp(0));
self
}
@ -137,7 +135,7 @@ impl OpChainSpecBuilder {
self.inner = self.inner.with_fork(EthereumHardfork::Cancun, ForkCondition::Timestamp(0));
self.inner = self
.inner
.with_fork(reth_optimism_forks::OptimismHardfork::Ecotone, ForkCondition::Timestamp(0));
.with_fork(reth_optimism_forks::OpHardfork::Ecotone, ForkCondition::Timestamp(0));
self
}
@ -146,7 +144,7 @@ impl OpChainSpecBuilder {
self = self.ecotone_activated();
self.inner = self
.inner
.with_fork(reth_optimism_forks::OptimismHardfork::Fjord, ForkCondition::Timestamp(0));
.with_fork(reth_optimism_forks::OpHardfork::Fjord, ForkCondition::Timestamp(0));
self
}
@ -155,17 +153,16 @@ impl OpChainSpecBuilder {
self = self.fjord_activated();
self.inner = self
.inner
.with_fork(reth_optimism_forks::OptimismHardfork::Granite, ForkCondition::Timestamp(0));
.with_fork(reth_optimism_forks::OpHardfork::Granite, ForkCondition::Timestamp(0));
self
}
/// Enable Holocene at genesis
pub fn holocene_activated(mut self) -> Self {
self = self.granite_activated();
self.inner = self.inner.with_fork(
reth_optimism_forks::OptimismHardfork::Holocene,
ForkCondition::Timestamp(0),
);
self.inner = self
.inner
.with_fork(reth_optimism_forks::OpHardfork::Holocene, ForkCondition::Timestamp(0));
self
}
@ -194,10 +191,9 @@ impl OpChainSpec {
parent: &Header,
timestamp: u64,
) -> Result<U256, DecodeError> {
let is_holocene_activated = self.inner.is_fork_active_at_timestamp(
reth_optimism_forks::OptimismHardfork::Holocene,
timestamp,
);
let is_holocene_activated = self
.inner
.is_fork_active_at_timestamp(reth_optimism_forks::OpHardfork::Holocene, timestamp);
// If we are in the Holocene, we need to use the base fee params
// from the parent block's extra data.
// Else, use the base fee params (default values) from chainspec
@ -344,7 +340,7 @@ impl OptimismHardforks for OpChainSpec {}
impl From<Genesis> for OpChainSpec {
fn from(genesis: Genesis) -> Self {
use reth_optimism_forks::OptimismHardfork;
use reth_optimism_forks::OpHardfork;
let optimism_genesis_info = OpGenesisInfo::extract_from(&genesis);
let genesis_info =
optimism_genesis_info.optimism_chain_info.genesis_info.unwrap_or_default();
@ -363,7 +359,7 @@ impl From<Genesis> for OpChainSpec {
(EthereumHardfork::London.boxed(), genesis.config.london_block),
(EthereumHardfork::ArrowGlacier.boxed(), genesis.config.arrow_glacier_block),
(EthereumHardfork::GrayGlacier.boxed(), genesis.config.gray_glacier_block),
(OptimismHardfork::Bedrock.boxed(), genesis_info.bedrock_block),
(OpHardfork::Bedrock.boxed(), genesis_info.bedrock_block),
];
let mut block_hardforks = hardfork_opts
.into_iter()
@ -391,11 +387,11 @@ impl From<Genesis> for OpChainSpec {
(EthereumHardfork::Shanghai.boxed(), genesis.config.shanghai_time),
(EthereumHardfork::Cancun.boxed(), genesis.config.cancun_time),
(EthereumHardfork::Prague.boxed(), genesis.config.prague_time),
(OptimismHardfork::Regolith.boxed(), genesis_info.regolith_time),
(OptimismHardfork::Canyon.boxed(), genesis_info.canyon_time),
(OptimismHardfork::Ecotone.boxed(), genesis_info.ecotone_time),
(OptimismHardfork::Fjord.boxed(), genesis_info.fjord_time),
(OptimismHardfork::Granite.boxed(), genesis_info.granite_time),
(OpHardfork::Regolith.boxed(), genesis_info.regolith_time),
(OpHardfork::Canyon.boxed(), genesis_info.canyon_time),
(OpHardfork::Ecotone.boxed(), genesis_info.ecotone_time),
(OpHardfork::Fjord.boxed(), genesis_info.fjord_time),
(OpHardfork::Granite.boxed(), genesis_info.granite_time),
];
let mut time_hardforks = time_hardfork_opts
@ -408,7 +404,7 @@ impl From<Genesis> for OpChainSpec {
block_hardforks.append(&mut time_hardforks);
// Ordered Hardforks
let mainnet_hardforks = OptimismHardfork::op_mainnet();
let mainnet_hardforks = OpHardfork::op_mainnet();
let mainnet_order = mainnet_hardforks.forks_iter();
let mut ordered_hardforks = Vec::with_capacity(block_hardforks.len());
@ -464,7 +460,7 @@ impl OpGenesisInfo {
BaseFeeParams::new(denominator as u128, elasticity as u128),
),
(
reth_optimism_forks::OptimismHardfork::Canyon.boxed(),
reth_optimism_forks::OpHardfork::Canyon.boxed(),
BaseFeeParams::new(canyon_denominator as u128, elasticity as u128),
),
]
@ -490,7 +486,7 @@ mod tests {
use alloy_primitives::b256;
use reth_chainspec::{test_fork_ids, BaseFeeParams, BaseFeeParamsKind};
use reth_ethereum_forks::{EthereumHardfork, ForkCondition, ForkHash, ForkId, Head};
use reth_optimism_forks::{OptimismHardfork, OptimismHardforks};
use reth_optimism_forks::{OpHardfork, OptimismHardforks};
use crate::*;
@ -763,19 +759,19 @@ mod tests {
BaseFeeParamsKind::Constant(BaseFeeParams::new(70, 60))
);
assert!(!chain_spec.is_fork_active_at_block(OptimismHardfork::Bedrock, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Canyon, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Ecotone, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Fjord, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Granite, 0));
assert!(!chain_spec.is_fork_active_at_block(OpHardfork::Bedrock, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Ecotone, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Fjord, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Granite, 0));
assert!(chain_spec.is_fork_active_at_block(OptimismHardfork::Bedrock, 10));
assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, 20));
assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Canyon, 30));
assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Ecotone, 40));
assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Fjord, 50));
assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Granite, 51));
assert!(chain_spec.is_fork_active_at_block(OpHardfork::Bedrock, 10));
assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, 20));
assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, 30));
assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Ecotone, 40));
assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Fjord, 50));
assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Granite, 51));
}
#[test]
@ -829,25 +825,25 @@ mod tests {
BaseFeeParamsKind::Variable(
vec![
(EthereumHardfork::London.boxed(), BaseFeeParams::new(70, 60)),
(OptimismHardfork::Canyon.boxed(), BaseFeeParams::new(80, 60)),
(OpHardfork::Canyon.boxed(), BaseFeeParams::new(80, 60)),
]
.into()
)
);
assert!(!chain_spec.is_fork_active_at_block(OptimismHardfork::Bedrock, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Canyon, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Ecotone, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Fjord, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Granite, 0));
assert!(!chain_spec.is_fork_active_at_block(OpHardfork::Bedrock, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Ecotone, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Fjord, 0));
assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Granite, 0));
assert!(chain_spec.is_fork_active_at_block(OptimismHardfork::Bedrock, 10));
assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, 20));
assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Canyon, 30));
assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Ecotone, 40));
assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Fjord, 50));
assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Granite, 51));
assert!(chain_spec.is_fork_active_at_block(OpHardfork::Bedrock, 10));
assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, 20));
assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, 30));
assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Ecotone, 40));
assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Fjord, 50));
assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Granite, 51));
}
#[test]
@ -921,14 +917,14 @@ mod tests {
})
);
assert!(chainspec.is_fork_active_at_block(OptimismHardfork::Bedrock, 0));
assert!(chainspec.is_fork_active_at_block(OpHardfork::Bedrock, 0));
assert!(chainspec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, 20));
assert!(chainspec.is_fork_active_at_timestamp(OpHardfork::Regolith, 20));
}
#[test]
fn test_fork_order_optimism_mainnet() {
use reth_optimism_forks::OptimismHardfork;
use reth_optimism_forks::OpHardfork;
let genesis = Genesis {
config: ChainConfig {
@ -984,14 +980,14 @@ mod tests {
EthereumHardfork::ArrowGlacier.boxed(),
EthereumHardfork::GrayGlacier.boxed(),
EthereumHardfork::Paris.boxed(),
OptimismHardfork::Bedrock.boxed(),
OptimismHardfork::Regolith.boxed(),
OpHardfork::Bedrock.boxed(),
OpHardfork::Regolith.boxed(),
EthereumHardfork::Shanghai.boxed(),
OptimismHardfork::Canyon.boxed(),
OpHardfork::Canyon.boxed(),
EthereumHardfork::Cancun.boxed(),
OptimismHardfork::Ecotone.boxed(),
OptimismHardfork::Fjord.boxed(),
OptimismHardfork::Granite.boxed(),
OpHardfork::Ecotone.boxed(),
OpHardfork::Fjord.boxed(),
OpHardfork::Granite.boxed(),
];
assert!(expected_hardforks
@ -1022,8 +1018,8 @@ mod tests {
}
fn holocene_chainspec() -> Arc<OpChainSpec> {
let mut hardforks = OptimismHardfork::base_sepolia();
hardforks.insert(OptimismHardfork::Holocene.boxed(), ForkCondition::Timestamp(1800000000));
let mut hardforks = OpHardfork::base_sepolia();
hardforks.insert(OpHardfork::Holocene.boxed(), ForkCondition::Timestamp(1800000000));
Arc::new(OpChainSpec {
inner: ChainSpec {
chain: BASE_SEPOLIA.inner.chain,

6
crates/optimism/chainspec/src/op.rs
View File

@ -7,7 +7,7 @@ use alloy_eips::eip1559::ETHEREUM_BLOCK_GAS_LIMIT;
use alloy_primitives::{b256, U256};
use reth_chainspec::{once_cell_set, BaseFeeParams, BaseFeeParamsKind, ChainSpec};
use reth_ethereum_forks::EthereumHardfork;
use reth_optimism_forks::OptimismHardfork;
use reth_optimism_forks::OpHardfork;
use crate::{LazyLock, OpChainSpec};
@ -24,11 +24,11 @@ pub static OP_MAINNET: LazyLock<Arc<OpChainSpec>> = LazyLock::new(|| {
"7ca38a1916c42007829c55e69d3e9a73265554b586a499015373241b8a3fa48b"
)),
paris_block_and_final_difficulty: Some((0, U256::from(0))),
hardforks: OptimismHardfork::op_mainnet(),
hardforks: OpHardfork::op_mainnet(),
base_fee_params: BaseFeeParamsKind::Variable(
vec![
(EthereumHardfork::London.boxed(), BaseFeeParams::optimism()),
(OptimismHardfork::Canyon.boxed(), BaseFeeParams::optimism_canyon()),
(OpHardfork::Canyon.boxed(), BaseFeeParams::optimism_canyon()),
]
.into(),
),

6
crates/optimism/chainspec/src/op_sepolia.rs
View File

@ -7,7 +7,7 @@ use alloy_eips::eip1559::ETHEREUM_BLOCK_GAS_LIMIT;
use alloy_primitives::{b256, U256};
use reth_chainspec::{once_cell_set, BaseFeeParams, BaseFeeParamsKind, ChainSpec};
use reth_ethereum_forks::EthereumHardfork;
use reth_optimism_forks::OptimismHardfork;
use reth_optimism_forks::OpHardfork;
use crate::{LazyLock, OpChainSpec};
@ -22,11 +22,11 @@ pub static OP_SEPOLIA: LazyLock<Arc<OpChainSpec>> = LazyLock::new(|| {
"102de6ffb001480cc9b8b548fd05c34cd4f46ae4aa91759393db90ea0409887d"
)),
paris_block_and_final_difficulty: Some((0, U256::from(0))),
hardforks: OptimismHardfork::op_sepolia(),
hardforks: OpHardfork::op_sepolia(),
base_fee_params: BaseFeeParamsKind::Variable(
vec![
(EthereumHardfork::London.boxed(), BaseFeeParams::optimism_sepolia()),
(OptimismHardfork::Canyon.boxed(), BaseFeeParams::optimism_sepolia_canyon()),
(OpHardfork::Canyon.boxed(), BaseFeeParams::optimism_sepolia_canyon()),
]
.into(),
),

10
crates/optimism/consensus/src/proof.rs
View File

@ -2,7 +2,7 @@
use alloy_primitives::B256;
use reth_chainspec::ChainSpec;
use reth_optimism_forks::OptimismHardfork;
use reth_optimism_forks::OpHardfork;
use reth_primitives::{Receipt, ReceiptWithBloom, ReceiptWithBloomRef};
use reth_trie_common::root::ordered_trie_root_with_encoder;
@ -17,8 +17,8 @@ pub(crate) fn calculate_receipt_root_optimism(
// encoding. In the Regolith Hardfork, we must strip the deposit nonce from the
// receipts before calculating the receipt root. This was corrected in the Canyon
// hardfork.
if chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, timestamp) &&
!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Canyon, timestamp)
if chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, timestamp) &&
!chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, timestamp)
{
let receipts = receipts
.iter()
@ -50,8 +50,8 @@ pub fn calculate_receipt_root_no_memo_optimism(
// encoding. In the Regolith Hardfork, we must strip the deposit nonce from the
// receipts before calculating the receipt root. This was corrected in the Canyon
// hardfork.
if chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, timestamp) &&
!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Canyon, timestamp)
if chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, timestamp) &&
!chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, timestamp)
{
let receipts = receipts
.iter()

28
crates/optimism/evm/src/config.rs
View File

@ -1,6 +1,6 @@
use reth_ethereum_forks::{EthereumHardfork, Head};
use reth_optimism_chainspec::OpChainSpec;
use reth_optimism_forks::OptimismHardfork;
use reth_optimism_forks::OpHardfork;
/// Returns the revm [`SpecId`](revm_primitives::SpecId) at the given timestamp.
///
@ -12,17 +12,17 @@ pub fn revm_spec_by_timestamp_after_bedrock(
chain_spec: &OpChainSpec,
timestamp: u64,
) -> revm_primitives::SpecId {
if chain_spec.fork(OptimismHardfork::Holocene).active_at_timestamp(timestamp) {
if chain_spec.fork(OpHardfork::Holocene).active_at_timestamp(timestamp) {
revm_primitives::HOLOCENE
} else if chain_spec.fork(OptimismHardfork::Granite).active_at_timestamp(timestamp) {
} else if chain_spec.fork(OpHardfork::Granite).active_at_timestamp(timestamp) {
revm_primitives::GRANITE
} else if chain_spec.fork(OptimismHardfork::Fjord).active_at_timestamp(timestamp) {
} else if chain_spec.fork(OpHardfork::Fjord).active_at_timestamp(timestamp) {
revm_primitives::FJORD
} else if chain_spec.fork(OptimismHardfork::Ecotone).active_at_timestamp(timestamp) {
} else if chain_spec.fork(OpHardfork::Ecotone).active_at_timestamp(timestamp) {
revm_primitives::ECOTONE
} else if chain_spec.fork(OptimismHardfork::Canyon).active_at_timestamp(timestamp) {
} else if chain_spec.fork(OpHardfork::Canyon).active_at_timestamp(timestamp) {
revm_primitives::CANYON
} else if chain_spec.fork(OptimismHardfork::Regolith).active_at_timestamp(timestamp) {
} else if chain_spec.fork(OpHardfork::Regolith).active_at_timestamp(timestamp) {
revm_primitives::REGOLITH
} else {
revm_primitives::BEDROCK
@ -31,19 +31,19 @@ pub fn revm_spec_by_timestamp_after_bedrock(
/// Map the latest active hardfork at the given block to a revm [`SpecId`](revm_primitives::SpecId).
pub fn revm_spec(chain_spec: &OpChainSpec, block: &Head) -> revm_primitives::SpecId {
if chain_spec.fork(OptimismHardfork::Holocene).active_at_head(block) {
if chain_spec.fork(OpHardfork::Holocene).active_at_head(block) {
revm_primitives::HOLOCENE
} else if chain_spec.fork(OptimismHardfork::Granite).active_at_head(block) {
} else if chain_spec.fork(OpHardfork::Granite).active_at_head(block) {
revm_primitives::GRANITE
} else if chain_spec.fork(OptimismHardfork::Fjord).active_at_head(block) {
} else if chain_spec.fork(OpHardfork::Fjord).active_at_head(block) {
revm_primitives::FJORD
} else if chain_spec.fork(OptimismHardfork::Ecotone).active_at_head(block) {
} else if chain_spec.fork(OpHardfork::Ecotone).active_at_head(block) {
revm_primitives::ECOTONE
} else if chain_spec.fork(OptimismHardfork::Canyon).active_at_head(block) {
} else if chain_spec.fork(OpHardfork::Canyon).active_at_head(block) {
revm_primitives::CANYON
} else if chain_spec.fork(OptimismHardfork::Regolith).active_at_head(block) {
} else if chain_spec.fork(OpHardfork::Regolith).active_at_head(block) {
revm_primitives::REGOLITH
} else if chain_spec.fork(OptimismHardfork::Bedrock).active_at_head(block) {
} else if chain_spec.fork(OpHardfork::Bedrock).active_at_head(block) {
revm_primitives::BEDROCK
} else if chain_spec.fork(EthereumHardfork::Prague).active_at_head(block) {
revm_primitives::PRAGUE

6
crates/optimism/evm/src/execute.rs
View File

@ -19,7 +19,7 @@ use reth_evm::{
};
use reth_optimism_chainspec::OpChainSpec;
use reth_optimism_consensus::validate_block_post_execution;
use reth_optimism_forks::OptimismHardfork;
use reth_optimism_forks::OpHardfork;
use reth_primitives::{BlockWithSenders, Header, Receipt, TxType};
use reth_revm::{Database, State};
use revm_primitives::{
@ -158,7 +158,7 @@ where
let mut evm = self.evm_config.evm_with_env(&mut self.state, env);
let is_regolith =
self.chain_spec.fork(OptimismHardfork::Regolith).active_at_timestamp(block.timestamp);
self.chain_spec.fork(OpHardfork::Regolith).active_at_timestamp(block.timestamp);
let mut cumulative_gas_used = 0;
let mut receipts = Vec::with_capacity(block.body.transactions.len());
@ -233,7 +233,7 @@ where
// this is only set for post-Canyon deposit transactions.
deposit_receipt_version: (transaction.is_deposit() &&
self.chain_spec
.is_fork_active_at_timestamp(OptimismHardfork::Canyon, block.timestamp))
.is_fork_active_at_timestamp(OpHardfork::Canyon, block.timestamp))
.then_some(1),
});
}

23
crates/optimism/evm/src/l1.rs
View File

@ -6,7 +6,7 @@ use alloy_primitives::{address, b256, hex, Address, Bytes, B256, U256};
use reth_chainspec::ChainSpec;
use reth_execution_errors::BlockExecutionError;
use reth_optimism_chainspec::OpChainSpec;
use reth_optimism_forks::OptimismHardfork;
use reth_optimism_forks::OpHardfork;
use reth_primitives::BlockBody;
use revm::{
primitives::{Bytecode, HashMap, SpecId},
@ -215,14 +215,13 @@ impl RethL1BlockInfo for L1BlockInfo {
return Ok(U256::ZERO)
}
let spec_id = if chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Fjord, timestamp)
{
let spec_id = if chain_spec.is_fork_active_at_timestamp(OpHardfork::Fjord, timestamp) {
SpecId::FJORD
} else if chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Ecotone, timestamp) {
} else if chain_spec.is_fork_active_at_timestamp(OpHardfork::Ecotone, timestamp) {
SpecId::ECOTONE
} else if chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, timestamp) {
} else if chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, timestamp) {
SpecId::REGOLITH
} else if chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Bedrock, timestamp) {
} else if chain_spec.is_fork_active_at_timestamp(OpHardfork::Bedrock, timestamp) {
SpecId::BEDROCK
} else {
return Err(OpBlockExecutionError::L1BlockInfoError {
@ -239,12 +238,11 @@ impl RethL1BlockInfo for L1BlockInfo {
timestamp: u64,
input: &[u8],
) -> Result<U256, BlockExecutionError> {
let spec_id = if chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Fjord, timestamp)
{
let spec_id = if chain_spec.is_fork_active_at_timestamp(OpHardfork::Fjord, timestamp) {
SpecId::FJORD
} else if chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, timestamp) {
} else if chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, timestamp) {
SpecId::REGOLITH
} else if chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Bedrock, timestamp) {
} else if chain_spec.is_fork_active_at_timestamp(OpHardfork::Bedrock, timestamp) {
SpecId::BEDROCK
} else {
return Err(OpBlockExecutionError::L1BlockInfoError {
@ -270,9 +268,8 @@ where
// If the canyon hardfork is active at the current timestamp, and it was not active at the
// previous block timestamp (heuristically, block time is not perfectly constant at 2s), and the
// chain is an optimism chain, then we need to force-deploy the create2 deployer contract.
if chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Canyon, timestamp) &&
!chain_spec
.is_fork_active_at_timestamp(OptimismHardfork::Canyon, timestamp.saturating_sub(2))
if chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, timestamp) &&
!chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, timestamp.saturating_sub(2))
{
trace!(target: "evm", "Forcing create2 deployer contract deployment on Canyon transition");

12
crates/optimism/hardforks/src/dev.rs
View File

@ -24,13 +24,13 @@ pub static DEV_HARDFORKS: LazyLock<ChainHardforks> = LazyLock::new(|| {
EthereumHardfork::Paris.boxed(),
ForkCondition::TTD { fork_block: None, total_difficulty: U256::ZERO },
),
(crate::OptimismHardfork::Bedrock.boxed(), ForkCondition::Block(0)),
(crate::OptimismHardfork::Regolith.boxed(), ForkCondition::Timestamp(0)),
(crate::OpHardfork::Bedrock.boxed(), ForkCondition::Block(0)),
(crate::OpHardfork::Regolith.boxed(), ForkCondition::Timestamp(0)),
(EthereumHardfork::Shanghai.boxed(), ForkCondition::Timestamp(0)),
(crate::OptimismHardfork::Canyon.boxed(), ForkCondition::Timestamp(0)),
(crate::OpHardfork::Canyon.boxed(), ForkCondition::Timestamp(0)),
(EthereumHardfork::Cancun.boxed(), ForkCondition::Timestamp(0)),
(crate::OptimismHardfork::Ecotone.boxed(), ForkCondition::Timestamp(0)),
(crate::OptimismHardfork::Fjord.boxed(), ForkCondition::Timestamp(0)),
(crate::OptimismHardfork::Granite.boxed(), ForkCondition::Timestamp(0)),
(crate::OpHardfork::Ecotone.boxed(), ForkCondition::Timestamp(0)),
(crate::OpHardfork::Fjord.boxed(), ForkCondition::Timestamp(0)),
(crate::OpHardfork::Granite.boxed(), ForkCondition::Timestamp(0)),
])
});

33
crates/optimism/hardforks/src/hardfork.rs
View File

@ -18,7 +18,7 @@ hardfork!(
///
/// When building a list of hardforks for a chain, it's still expected to mix with
/// [`EthereumHardfork`].
OptimismHardfork {
OpHardfork {
/// Bedrock: <https://blog.oplabs.co/introducing-optimism-bedrock>.
Bedrock,
/// Regolith: <https://github.com/ethereum-optimism/specs/blob/main/specs/protocol/superchain-upgrades.md#regolith>.
@ -36,7 +36,7 @@ hardfork!(
}
);
impl OptimismHardfork {
impl OpHardfork {
/// Retrieves the activation block for the specified hardfork on the given chain.
pub fn activation_block<H: Hardfork>(self, fork: H, chain: Chain) -> Option<u64> {
if chain == Chain::base_sepolia() {
@ -328,13 +328,13 @@ fn match_hardfork<H, HF, OHF>(fork: H, hardfork_fn: HF, optimism_hardfork_fn: OH
where
H: Hardfork,
HF: Fn(&EthereumHardfork) -> Option<u64>,
OHF: Fn(&OptimismHardfork) -> Option<u64>,
OHF: Fn(&OpHardfork) -> Option<u64>,
{
let fork: &dyn Any = &fork;
if let Some(fork) = fork.downcast_ref::<EthereumHardfork>() {
return hardfork_fn(fork)
}
fork.downcast_ref::<OptimismHardfork>().and_then(optimism_hardfork_fn)
fork.downcast_ref::<OpHardfork>().and_then(optimism_hardfork_fn)
}
#[cfg(test)]
@ -346,35 +346,32 @@ mod tests {
#[test]
fn test_match_hardfork() {
assert_eq!(
OptimismHardfork::base_mainnet_activation_block(EthereumHardfork::Cancun),
OpHardfork::base_mainnet_activation_block(EthereumHardfork::Cancun),
Some(11188936)
);
assert_eq!(
OptimismHardfork::base_mainnet_activation_block(OptimismHardfork::Canyon),
Some(9101527)
);
assert_eq!(OpHardfork::base_mainnet_activation_block(OpHardfork::Canyon), Some(9101527));
}
#[test]
fn check_op_hardfork_from_str() {
let hardfork_str = ["beDrOck", "rEgOlITH", "cAnYoN", "eCoToNe", "FJorD", "GRaNiTe"];
let expected_hardforks = [
OptimismHardfork::Bedrock,
OptimismHardfork::Regolith,
OptimismHardfork::Canyon,
OptimismHardfork::Ecotone,
OptimismHardfork::Fjord,
OptimismHardfork::Granite,
OpHardfork::Bedrock,
OpHardfork::Regolith,
OpHardfork::Canyon,
OpHardfork::Ecotone,
OpHardfork::Fjord,
OpHardfork::Granite,
];
let hardforks: Vec<OptimismHardfork> =
hardfork_str.iter().map(|h| OptimismHardfork::from_str(h).unwrap()).collect();
let hardforks: Vec<OpHardfork> =
hardfork_str.iter().map(|h| OpHardfork::from_str(h).unwrap()).collect();
assert_eq!(hardforks, expected_hardforks);
}
#[test]
fn check_nonexistent_hardfork_from_str() {
assert!(OptimismHardfork::from_str("not a hardfork").is_err());
assert!(OpHardfork::from_str("not a hardfork").is_err());
}
}

30
crates/optimism/hardforks/src/lib.rs
View File

@ -14,47 +14,47 @@ pub mod hardfork;
mod dev;
pub use dev::DEV_HARDFORKS;
pub use hardfork::OptimismHardfork;
pub use hardfork::OpHardfork;
use reth_ethereum_forks::EthereumHardforks;
/// Extends [`EthereumHardforks`] with optimism helper methods.
pub trait OptimismHardforks: EthereumHardforks {
/// Convenience method to check if [`OptimismHardfork::Bedrock`] is active at a given block
/// Convenience method to check if [`OpHardfork::Bedrock`] is active at a given block
/// number.
fn is_bedrock_active_at_block(&self, block_number: u64) -> bool {
self.fork(OptimismHardfork::Bedrock).active_at_block(block_number)
self.fork(OpHardfork::Bedrock).active_at_block(block_number)
}
/// Returns `true` if [`Canyon`](OptimismHardfork::Canyon) is active at given block timestamp.
/// Returns `true` if [`Canyon`](OpHardfork::Canyon) is active at given block timestamp.
fn is_canyon_active_at_timestamp(&self, timestamp: u64) -> bool {
self.fork(OptimismHardfork::Canyon).active_at_timestamp(timestamp)
self.fork(OpHardfork::Canyon).active_at_timestamp(timestamp)
}
/// Returns `true` if [`Ecotone`](OptimismHardfork::Ecotone) is active at given block timestamp.
/// Returns `true` if [`Ecotone`](OpHardfork::Ecotone) is active at given block timestamp.
fn is_ecotone_active_at_timestamp(&self, timestamp: u64) -> bool {
self.fork(OptimismHardfork::Ecotone).active_at_timestamp(timestamp)
self.fork(OpHardfork::Ecotone).active_at_timestamp(timestamp)
}
/// Returns `true` if [`Fjord`](OptimismHardfork::Fjord) is active at given block timestamp.
/// Returns `true` if [`Fjord`](OpHardfork::Fjord) is active at given block timestamp.
fn is_fjord_active_at_timestamp(&self, timestamp: u64) -> bool {
self.fork(OptimismHardfork::Fjord).active_at_timestamp(timestamp)
self.fork(OpHardfork::Fjord).active_at_timestamp(timestamp)
}
/// Returns `true` if [`Granite`](OptimismHardfork::Granite) is active at given block timestamp.
/// Returns `true` if [`Granite`](OpHardfork::Granite) is active at given block timestamp.
fn is_granite_active_at_timestamp(&self, timestamp: u64) -> bool {
self.fork(OptimismHardfork::Granite).active_at_timestamp(timestamp)
self.fork(OpHardfork::Granite).active_at_timestamp(timestamp)
}
/// Returns `true` if [`Holocene`](OptimismHardfork::Holocene) is active at given block
/// Returns `true` if [`Holocene`](OpHardfork::Holocene) is active at given block
/// timestamp.
fn is_holocene_active_at_timestamp(&self, timestamp: u64) -> bool {
self.fork(OptimismHardfork::Holocene).active_at_timestamp(timestamp)
self.fork(OpHardfork::Holocene).active_at_timestamp(timestamp)
}
/// Returns `true` if [`Regolith`](OptimismHardfork::Regolith) is active at given block
/// Returns `true` if [`Regolith`](OpHardfork::Regolith) is active at given block
/// timestamp.
fn is_regolith_active_at_timestamp(&self, timestamp: u64) -> bool {
self.fork(OptimismHardfork::Regolith).active_at_timestamp(timestamp)
self.fork(OpHardfork::Regolith).active_at_timestamp(timestamp)
}
}

9
crates/optimism/node/src/engine.rs
View File

@ -14,7 +14,7 @@ use reth_node_api::{
validate_version_specific_fields, EngineTypes, EngineValidator,
};
use reth_optimism_chainspec::OpChainSpec;
use reth_optimism_forks::{OptimismHardfork, OptimismHardforks};
use reth_optimism_forks::{OpHardfork, OptimismHardforks};
use reth_optimism_payload_builder::{OpBuiltPayload, OpPayloadBuilderAttributes};
/// The types used in the optimism beacon consensus engine.
@ -81,7 +81,7 @@ pub fn validate_withdrawals_presence(
timestamp: u64,
has_withdrawals: bool,
) -> Result<(), EngineObjectValidationError> {
let is_shanghai = chain_spec.fork(OptimismHardfork::Canyon).active_at_timestamp(timestamp);
let is_shanghai = chain_spec.fork(OpHardfork::Canyon).active_at_timestamp(timestamp);
match version {
EngineApiMessageVersion::V1 => {
@ -178,10 +178,9 @@ mod test {
use super::*;
fn get_chainspec(is_holocene: bool) -> Arc<OpChainSpec> {
let mut hardforks = OptimismHardfork::base_sepolia();
let mut hardforks = OpHardfork::base_sepolia();
if is_holocene {
hardforks
.insert(OptimismHardfork::Holocene.boxed(), ForkCondition::Timestamp(1800000000));
hardforks.insert(OpHardfork::Holocene.boxed(), ForkCondition::Timestamp(1800000000));
}
Arc::new(OpChainSpec {
inner: ChainSpec {