tempo_consensus/

lib.rs

//! Tempo consensus implementation.

#![cfg_attr(not(test), warn(unused_crate_dependencies))]
#![cfg_attr(docsrs, feature(doc_cfg))]

mod error;

use alloy_consensus::{BlockHeader, Transaction, transaction::TxHashRef};
use alloy_evm::block::BlockExecutionResult;
pub use error::TempoConsensusError;
use reth_chainspec::EthChainSpec;
use reth_consensus::{Consensus, ConsensusError, FullConsensus, HeaderValidator, ReceiptRootBloom};
use reth_consensus_common::validation::{
    validate_against_parent_4844, validate_against_parent_eip1559_base_fee,
    validate_against_parent_gas_limit, validate_against_parent_hash_number,
};
use reth_ethereum_consensus::EthBeaconConsensus;
use reth_primitives_traits::{RecoveredBlock, SealedBlock, SealedHeader};
use std::sync::Arc;
use tempo_chainspec::{
    hardfork::TempoHardforks,
    spec::{SYSTEM_TX_ADDRESSES, SYSTEM_TX_COUNT, TempoChainSpec},
};
use tempo_primitives::{
    Block, BlockBody, TempoHeader, TempoPrimitives, TempoReceipt, TempoTxEnvelope,
};

/// How far in the future the block timestamp can be.
///
/// We are setting this to 0 to not allow any drift of the block time in the future.
/// We are considering this safe because with the way CL works currently block time would
/// be consistent and thus an honest proposer should never produce a block that appears
/// to be in the future even assuming 50-100ms clock drift.
pub const ALLOWED_FUTURE_BLOCK_TIME_MILLIS: u64 = 0;

/// Divisor for calculating shared gas limit (payment lane capacity).
/// shared_gas_limit = block_gas_limit / TEMPO_SHARED_GAS_DIVISOR
pub const TEMPO_SHARED_GAS_DIVISOR: u64 = 10;

/// Maximum extra data size for Tempo blocks.
pub const TEMPO_MAXIMUM_EXTRA_DATA_SIZE: usize = 10 * 1_024; // 10KiB

/// Tempo consensus implementation.
#[derive(Debug, Clone)]
pub struct TempoConsensus {
    /// Inner Ethereum consensus.
    inner: EthBeaconConsensus<TempoChainSpec>,
}

impl TempoConsensus {
    /// Creates a new [`TempoConsensus`] with the given chain spec.
    pub fn new(chain_spec: Arc<TempoChainSpec>) -> Self {
        Self {
            inner: EthBeaconConsensus::new(chain_spec)
                .with_max_extra_data_size(TEMPO_MAXIMUM_EXTRA_DATA_SIZE),
        }
    }

    /// Validates the given header against common consensus rules and the given millisecond timestamp.
    fn validate_header_with_timestamp_millis(
        &self,
        header: &SealedHeader<TempoHeader>,
        present_timestamp_millis: u64,
    ) -> Result<(), ConsensusError> {
        self.inner.validate_header(header)?;

        // Validate the timestamp milliseconds part
        if header.timestamp_millis_part >= 1000 {
            return Err(TempoConsensusError::InvalidTimestampMillisPart {
                millis_part: header.timestamp_millis_part,
            }
            .into());
        }

        if header.timestamp_millis() > present_timestamp_millis + ALLOWED_FUTURE_BLOCK_TIME_MILLIS {
            return Err(ConsensusError::TimestampIsInFuture {
                timestamp: header.timestamp_millis(),
                present_timestamp: present_timestamp_millis,
            });
        }

        let expected_shared = header.gas_limit() / TEMPO_SHARED_GAS_DIVISOR;
        if header.shared_gas_limit != expected_shared {
            return Err(TempoConsensusError::SharedGasLimitMismatch {
                expected: expected_shared,
                actual: header.shared_gas_limit,
            }
            .into());
        }

        // Validate the general (non-payment) gas limit
        let expected_general_gas_limit = self.inner.chain_spec().general_gas_limit_at(
            header.timestamp(),
            header.gas_limit(),
            header.shared_gas_limit,
        );

        if header.general_gas_limit != expected_general_gas_limit {
            return Err(TempoConsensusError::GeneralGasLimitMismatch {
                expected: expected_general_gas_limit,
                actual: header.general_gas_limit,
            }
            .into());
        }

        Ok(())
    }
}

impl HeaderValidator<TempoHeader> for TempoConsensus {
    fn validate_header(&self, header: &SealedHeader<TempoHeader>) -> Result<(), ConsensusError> {
        let current_timestamp_millis = std::time::SystemTime::now()
            .duration_since(std::time::SystemTime::UNIX_EPOCH)
            .expect("system time should never be before UNIX EPOCH")
            .as_millis() as u64;
        self.validate_header_with_timestamp_millis(header, current_timestamp_millis)
    }

    fn validate_header_against_parent(
        &self,
        header: &SealedHeader<TempoHeader>,
        parent: &SealedHeader<TempoHeader>,
    ) -> Result<(), ConsensusError> {
        validate_against_parent_hash_number(header.header(), parent)?;

        validate_against_parent_gas_limit(header, parent, self.inner.chain_spec())?;

        validate_against_parent_eip1559_base_fee(
            header.header(),
            parent.header(),
            self.inner.chain_spec(),
        )?;

        if let Some(blob_params) = self
            .inner
            .chain_spec()
            .blob_params_at_timestamp(header.timestamp())
        {
            validate_against_parent_4844(header.header(), parent.header(), blob_params)?;
        }

        if header.timestamp_millis() <= parent.timestamp_millis() {
            return Err(ConsensusError::TimestampIsInPast {
                parent_timestamp: parent.timestamp_millis(),
                timestamp: header.timestamp_millis(),
            });
        }

        Ok(())
    }
}

impl Consensus<Block> for TempoConsensus {
    fn validate_body_against_header(
        &self,
        body: &BlockBody,
        header: &SealedHeader<TempoHeader>,
    ) -> Result<(), ConsensusError> {
        Consensus::<Block>::validate_body_against_header(&self.inner, body, header)
    }

    fn validate_block_pre_execution(
        &self,
        block: &SealedBlock<Block>,
    ) -> Result<(), ConsensusError> {
        let transactions = &block.body().transactions;

        if let Some(tx) = transactions.iter().find(|&tx| {
            tx.is_system_tx() && !tx.is_valid_system_tx(self.inner.chain_spec().chain().id())
        }) {
            return Err(TempoConsensusError::InvalidSystemTransaction {
                tx_hash: *tx.tx_hash(),
            }
            .into());
        }

        let expected_system_tx_count = if self
            .inner
            .chain_spec()
            .is_t4_active_at_timestamp(block.header().timestamp())
        {
            0
        } else {
            SYSTEM_TX_COUNT
        };

        // Get the last END_OF_BLOCK_SYSTEM_TX_COUNT transactions and validate they are end-of-block system txs
        let end_of_block_system_txs = transactions
            .get(transactions.len().saturating_sub(expected_system_tx_count)..)
            .map(|slice| {
                slice
                    .iter()
                    .filter(|tx| tx.is_system_tx())
                    .collect::<Vec<&TempoTxEnvelope>>()
            })
            .unwrap_or_default();

        if end_of_block_system_txs.len() != expected_system_tx_count {
            return Err(TempoConsensusError::MissingEndOfBlockSystemTxs {
                expected: expected_system_tx_count,
                actual: end_of_block_system_txs.len(),
            }
            .into());
        }

        // Validate that the sequence of end-of-block system txs is correct
        for (tx, expected_to) in end_of_block_system_txs.into_iter().zip(SYSTEM_TX_ADDRESSES) {
            let actual_to = tx.to().unwrap_or_default();
            if actual_to != expected_to {
                return Err(TempoConsensusError::InvalidEndOfBlockSystemTxOrder {
                    expected: expected_to,
                    actual: actual_to,
                }
                .into());
            }
        }

        self.inner.validate_block_pre_execution(block)
    }

    fn is_transient_error(&self, error: &ConsensusError) -> bool {
        // Future timestamps can happen briefly when clocks drift between nodes.
        Consensus::<Block>::is_transient_error(&self.inner, error)
            || matches!(error, ConsensusError::TimestampIsInFuture { .. })
    }
}

impl FullConsensus<TempoPrimitives> for TempoConsensus {
    fn validate_block_post_execution(
        &self,
        block: &RecoveredBlock<Block>,
        result: &BlockExecutionResult<TempoReceipt>,
        receipt_root_bloom: Option<ReceiptRootBloom>,
        block_access_list_hash: Option<alloy_primitives::B256>,
    ) -> Result<(), ConsensusError> {
        FullConsensus::<TempoPrimitives>::validate_block_post_execution(
            &self.inner,
            block,
            result,
            receipt_root_bloom,
            block_access_list_hash,
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use alloy_consensus::{
        Header, Signed, TxLegacy, constants::EMPTY_ROOT_HASH, proofs::calculate_transaction_root,
        transaction::TxHashRef,
    };
    use alloy_genesis::Genesis;
    use alloy_primitives::{Address, B256, Signature, TxKind, U256};
    use reth_primitives_traits::SealedHeader;
    use std::time::{SystemTime, UNIX_EPOCH};
    use tempo_chainspec::{
        hardfork::TempoHardfork,
        spec::{DEV, MODERATO, TempoChainSpec},
    };

    fn current_timestamp_millis() -> u64 {
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64
    }

    #[derive(Default)]
    struct TestHeaderBuilder {
        gas_limit: u64,
        timestamp: u64,
        timestamp_millis_part: u64,
        number: u64,
        parent_hash: B256,
        shared_gas_limit: Option<u64>,
        general_gas_limit: Option<u64>,
        base_fee: Option<u64>,
    }

    impl TestHeaderBuilder {
        fn gas_limit(mut self, gas_limit: u64) -> Self {
            self.gas_limit = gas_limit;
            self
        }

        fn timestamp_millis(mut self, timestamp: u64) -> Self {
            self.timestamp = timestamp / 1000;
            self.timestamp_millis_part = timestamp % 1000;
            self
        }

        fn timestamp(mut self, timestamp: u64) -> Self {
            self.timestamp = timestamp;
            self
        }

        fn timestamp_millis_part(mut self, millis: u64) -> Self {
            self.timestamp_millis_part = millis;
            self
        }

        fn number(mut self, number: u64) -> Self {
            self.number = number;
            self
        }

        fn parent_hash(mut self, hash: B256) -> Self {
            self.parent_hash = hash;
            self
        }

        fn shared_gas_limit(mut self, limit: u64) -> Self {
            self.shared_gas_limit = Some(limit);
            self
        }

        fn general_gas_limit(mut self, limit: u64) -> Self {
            self.general_gas_limit = Some(limit);
            self
        }

        fn base_fee(mut self, fee: u64) -> Self {
            self.base_fee = Some(fee);
            self
        }

        fn build(self) -> TempoHeader {
            let shared_gas_limit = self
                .shared_gas_limit
                .unwrap_or(self.gas_limit / TEMPO_SHARED_GAS_DIVISOR);
            // Default to T1 fixed general gas limit
            let general_gas_limit = self
                .general_gas_limit
                .unwrap_or(tempo_chainspec::spec::TEMPO_T1_GENERAL_GAS_LIMIT);

            TempoHeader {
                inner: Header {
                    gas_limit: self.gas_limit,
                    timestamp: self.timestamp,
                    number: self.number,
                    parent_hash: self.parent_hash,
                    base_fee_per_gas: Some(
                        self.base_fee
                            .unwrap_or(tempo_chainspec::spec::TEMPO_T0_BASE_FEE),
                    ),
                    withdrawals_root: Some(EMPTY_ROOT_HASH),
                    blob_gas_used: Some(0),
                    excess_blob_gas: Some(0),
                    parent_beacon_block_root: Some(B256::ZERO),
                    requests_hash: Some(B256::ZERO),
                    ..Default::default()
                },
                shared_gas_limit,
                general_gas_limit,
                timestamp_millis_part: self.timestamp_millis_part,
                ..Default::default()
            }
        }
    }

    fn create_valid_block(header: TempoHeader, transactions: Vec<TempoTxEnvelope>) -> Block {
        let transactions_root = calculate_transaction_root(&transactions);
        let mut header = header;
        header.inner.transactions_root = transactions_root;

        Block {
            header,
            body: BlockBody {
                transactions,
                withdrawals: Some(Default::default()),
                ..Default::default()
            },
        }
    }

    fn create_system_tx(chain_id: u64, to: Address) -> TempoTxEnvelope {
        let tx = TxLegacy {
            chain_id: Some(chain_id),
            nonce: 0,
            gas_price: 0,
            gas_limit: 0,
            to: TxKind::Call(to),
            value: U256::ZERO,
            input: Default::default(),
        };
        let signature = Signature::new(U256::ZERO, U256::ZERO, false);
        TempoTxEnvelope::Legacy(Signed::new_unhashed(tx, signature))
    }

    fn create_tx(chain_id: u64) -> TempoTxEnvelope {
        let tx = TxLegacy {
            chain_id: Some(chain_id),
            nonce: 1,
            gas_price: 1_000_000_000,
            gas_limit: 21000,
            to: TxKind::Call(Address::repeat_byte(0x42)),
            value: U256::from(100),
            input: Default::default(),
        };
        TempoTxEnvelope::Legacy(Signed::new_unhashed(tx, Signature::test_signature()))
    }

    #[test]
    fn test_validate_header() {
        let consensus = TempoConsensus::new(MODERATO.clone());
        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp_millis(current_timestamp_millis())
            .build();
        let sealed = SealedHeader::seal_slow(header);

        assert!(consensus.validate_header(&sealed).is_ok());
    }

    #[test]
    fn test_validate_header_shared_gas_mismatch() {
        let consensus = TempoConsensus::new(MODERATO.clone());
        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp_millis(current_timestamp_millis())
            .shared_gas_limit(999)
            .build();
        let sealed = SealedHeader::seal_slow(header);

        let result = consensus.validate_header(&sealed);
        let err = result.unwrap_err();
        assert!(
            err.downcast_other_ref::<TempoConsensusError>()
                .is_some_and(|e| matches!(e, TempoConsensusError::SharedGasLimitMismatch { .. })),
            "Expected SharedGasLimitMismatch, got: {err:?}"
        );
    }

    #[test]
    fn test_validate_header_general_gas_mismatch_pre_t1() {
        // Pre-T1 chainspec uses the divisor-based calculation
        let consensus = TempoConsensus::new(create_pre_t1_chainspec());
        let gas_limit = 500_000_000u64;
        let shared_gas_limit = gas_limit / TEMPO_SHARED_GAS_DIVISOR;
        // Pre-T1: expected = (gas_limit - shared_gas_limit) / 2
        let header = TestHeaderBuilder::default()
            .gas_limit(gas_limit)
            .timestamp_millis(current_timestamp_millis())
            .general_gas_limit(999)
            .build();
        let sealed = SealedHeader::seal_slow(header);

        let result = consensus.validate_header(&sealed);
        let err = result.unwrap_err();
        assert!(
            err.downcast_other_ref::<TempoConsensusError>()
                .is_some_and(|e| matches!(e, TempoConsensusError::GeneralGasLimitMismatch { .. })),
            "Expected GeneralGasLimitMismatch, got: {err:?}",
        );

        // Now verify the correct pre-T1 value works
        let expected_general_gas_limit = (gas_limit - shared_gas_limit) / 2;
        let header = TestHeaderBuilder::default()
            .gas_limit(gas_limit)
            .timestamp_millis(current_timestamp_millis())
            .general_gas_limit(expected_general_gas_limit)
            .build();
        let sealed = SealedHeader::seal_slow(header);
        assert!(consensus.validate_header(&sealed).is_ok());
    }

    /// Creates a chainspec with only T0 active (no T1).
    fn create_pre_t1_chainspec() -> Arc<TempoChainSpec> {
        let genesis_json = r#"{
            "config": {
                "chainId": 99998,
                "homesteadBlock": 0,
                "daoForkSupport": false,
                "eip150Block": 0,
                "eip155Block": 0,
                "eip158Block": 0,
                "byzantiumBlock": 0,
                "constantinopleBlock": 0,
                "petersburgBlock": 0,
                "istanbulBlock": 0,
                "berlinBlock": 0,
                "londonBlock": 0,
                "mergeNetsplitBlock": 0,
                "shanghaiTime": 0,
                "cancunTime": 0,
                "pragueTime": 0,
                "osakaTime": 0,
                "terminalTotalDifficulty": 0,
                "terminalTotalDifficultyPassed": true,
                "epochLength": 21600,
                "t0Time": 0
            },
            "nonce": "0x42",
            "timestamp": "0x0",
            "extraData": "0x",
            "gasLimit": "0x1dcd6500",
            "difficulty": "0x0",
            "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
            "coinbase": "0x0000000000000000000000000000000000000000",
            "alloc": {}
        }"#;
        let genesis: Genesis = serde_json::from_str(genesis_json).unwrap();
        Arc::new(TempoChainSpec::from_genesis(genesis))
    }

    /// Creates a chainspec with T1 active at timestamp 0.
    fn create_t1_chainspec() -> Arc<TempoChainSpec> {
        let genesis_json = r#"{
            "config": {
                "chainId": 99999,
                "homesteadBlock": 0,
                "daoForkSupport": false,
                "eip150Block": 0,
                "eip155Block": 0,
                "eip158Block": 0,
                "byzantiumBlock": 0,
                "constantinopleBlock": 0,
                "petersburgBlock": 0,
                "istanbulBlock": 0,
                "berlinBlock": 0,
                "londonBlock": 0,
                "mergeNetsplitBlock": 0,
                "shanghaiTime": 0,
                "cancunTime": 0,
                "pragueTime": 0,
                "osakaTime": 0,
                "terminalTotalDifficulty": 0,
                "terminalTotalDifficultyPassed": true,
                "epochLength": 21600,
                "t0Time": 0,
                "t1Time": 0
            },
            "nonce": "0x42",
            "timestamp": "0x0",
            "extraData": "0x",
            "gasLimit": "0x1dcd6500",
            "difficulty": "0x0",
            "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
            "coinbase": "0x0000000000000000000000000000000000000000",
            "alloc": {}
        }"#;
        let genesis: Genesis = serde_json::from_str(genesis_json).unwrap();
        Arc::new(TempoChainSpec::from_genesis(genesis))
    }

    #[test]
    fn test_validate_header_general_gas_limit_t1() {
        // Create a chainspec with T1 active at timestamp 0
        let chainspec = create_t1_chainspec();
        let consensus = TempoConsensus::new(chainspec);
        let gas_limit = 500_000_000u64;

        // T1+: general gas limit must be fixed at 30M
        // Test with wrong value
        let header = TestHeaderBuilder::default()
            .gas_limit(gas_limit)
            .timestamp_millis(current_timestamp_millis())
            .general_gas_limit(999)
            .build();
        let sealed = SealedHeader::seal_slow(header);

        let result = consensus.validate_header(&sealed);
        let err = result.unwrap_err();
        assert!(
            err.downcast_other_ref::<TempoConsensusError>()
                .is_some_and(|e| matches!(e, TempoConsensusError::GeneralGasLimitMismatch { .. })),
            "Expected GeneralGasLimitMismatch, got: {err:?}",
        );

        // Now verify the correct T1 value works (fixed 30M)
        let header = TestHeaderBuilder::default()
            .gas_limit(gas_limit)
            .timestamp_millis(current_timestamp_millis())
            .general_gas_limit(TempoHardfork::T1.general_gas_limit().unwrap())
            .build();
        let sealed = SealedHeader::seal_slow(header);
        consensus.validate_header(&sealed).expect("should be valid");
    }

    #[test]
    fn test_validate_header_timestamp_milli_gte_1000() {
        let consensus = TempoConsensus::new(MODERATO.clone());

        let current_timestamp_millis = 1000000999;

        // Test timestamp equal to 1000
        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp_millis(current_timestamp_millis)
            .timestamp_millis_part(1000)
            .build();
        let sealed = SealedHeader::seal_slow(header);

        let result =
            consensus.validate_header_with_timestamp_millis(&sealed, current_timestamp_millis);
        let err = result.unwrap_err();
        assert!(
            err.downcast_other_ref::<TempoConsensusError>()
                .is_some_and(|e| matches!(
                    e,
                    TempoConsensusError::InvalidTimestampMillisPart { millis_part: 1000 }
                )),
            "Expected InvalidTimestampMillisPart, got: {err:?}"
        );

        // Test timestamp > 1000
        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp_millis(current_timestamp_millis)
            .timestamp_millis_part(1001)
            .build();
        let sealed = SealedHeader::seal_slow(header);
        let result =
            consensus.validate_header_with_timestamp_millis(&sealed, current_timestamp_millis);
        let err = result.unwrap_err();
        assert!(
            err.downcast_other_ref::<TempoConsensusError>()
                .is_some_and(|e| matches!(
                    e,
                    TempoConsensusError::InvalidTimestampMillisPart { millis_part: 1001 }
                )),
            "Expected InvalidTimestampMillisPart, got: {err:?}"
        );
    }

    #[test]
    fn test_validate_header_against_parent() {
        use tempo_chainspec::spec::TEMPO_T1_BASE_FEE;

        let consensus = TempoConsensus::new(MODERATO.clone());
        let parent_ts = current_timestamp_millis() - 1;
        let parent = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(parent_ts)
            .number(1)
            .timestamp_millis_part(500)
            .base_fee(TEMPO_T1_BASE_FEE)
            .build();
        let parent_sealed = SealedHeader::seal_slow(parent);

        let child = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(parent_ts + 1)
            .timestamp_millis_part(600)
            .number(2)
            .base_fee(TEMPO_T1_BASE_FEE)
            .parent_hash(parent_sealed.hash())
            .build();
        let child_sealed = SealedHeader::seal_slow(child);

        let result = consensus.validate_header_against_parent(&child_sealed, &parent_sealed);
        assert!(result.is_ok());
    }

    #[test]
    fn test_validate_header_against_parent_timestamp_not_increasing() {
        use tempo_chainspec::spec::TEMPO_T1_BASE_FEE;

        let consensus = TempoConsensus::new(MODERATO.clone());
        let parent_ts = current_timestamp_millis();
        let parent = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(parent_ts)
            .timestamp_millis_part(500)
            .base_fee(TEMPO_T1_BASE_FEE)
            .build();
        let parent_sealed = SealedHeader::seal_slow(parent);

        let child = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(parent_ts)
            .timestamp_millis_part(400)
            .number(1)
            .base_fee(TEMPO_T1_BASE_FEE)
            .parent_hash(parent_sealed.hash())
            .build();
        let child_sealed = SealedHeader::seal_slow(child);

        let result = consensus.validate_header_against_parent(&child_sealed, &parent_sealed);
        assert!(matches!(
            result,
            Err(ConsensusError::TimestampIsInPast { .. })
        ));
    }

    #[test]
    fn test_validate_header_against_parent_t1() {
        use tempo_chainspec::spec::TEMPO_T1_BASE_FEE;

        let chainspec = create_t1_chainspec();
        let consensus = TempoConsensus::new(chainspec);

        let parent_ts = current_timestamp_millis() - 1;
        let parent = TestHeaderBuilder::default()
            .gas_limit(500_000_000)
            .timestamp(parent_ts)
            .number(1)
            .timestamp_millis_part(500)
            .general_gas_limit(TempoHardfork::T1.general_gas_limit().unwrap())
            .base_fee(TEMPO_T1_BASE_FEE)
            .build();
        let parent_sealed = SealedHeader::seal_slow(parent);

        let child = TestHeaderBuilder::default()
            .gas_limit(500_000_000)
            .timestamp(parent_ts + 1)
            .timestamp_millis_part(600)
            .number(2)
            .parent_hash(parent_sealed.hash())
            .general_gas_limit(TempoHardfork::T1.general_gas_limit().unwrap())
            .base_fee(TEMPO_T1_BASE_FEE)
            .build();
        let child_sealed = SealedHeader::seal_slow(child);

        let result = consensus.validate_header_against_parent(&child_sealed, &parent_sealed);
        assert!(result.is_ok(), "T1 validation failed: {result:?}");
    }

    #[test]
    fn test_validate_header_against_parent_t1_wrong_base_fee() {
        use tempo_chainspec::spec::{TEMPO_T0_BASE_FEE, TEMPO_T1_BASE_FEE};

        let chainspec = create_t1_chainspec();
        let consensus = TempoConsensus::new(chainspec);

        let parent_ts = current_timestamp_millis() - 1;
        let parent = TestHeaderBuilder::default()
            .gas_limit(500_000_000)
            .timestamp(parent_ts)
            .number(1)
            .timestamp_millis_part(500)
            .general_gas_limit(TempoHardfork::T1.general_gas_limit().unwrap())
            .base_fee(TEMPO_T1_BASE_FEE)
            .build();
        let parent_sealed = SealedHeader::seal_slow(parent);

        // Child uses pre-T1 base fee (wrong for T1 chainspec)
        let child = TestHeaderBuilder::default()
            .gas_limit(500_000_000)
            .timestamp(parent_ts + 1)
            .timestamp_millis_part(600)
            .number(2)
            .parent_hash(parent_sealed.hash())
            .general_gas_limit(TempoHardfork::T1.general_gas_limit().unwrap())
            .base_fee(TEMPO_T0_BASE_FEE)
            .build();
        let child_sealed = SealedHeader::seal_slow(child);

        let result = consensus.validate_header_against_parent(&child_sealed, &parent_sealed);
        assert!(
            matches!(result, Err(ConsensusError::BaseFeeDiff(_))),
            "Expected BaseFeeDiff error, got: {result:?}"
        );
    }

    #[test]
    fn test_validate_body_against_header() {
        let consensus = TempoConsensus::new(MODERATO.clone());
        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(current_timestamp_millis())
            .build();
        let sealed = SealedHeader::seal_slow(header);
        let body = BlockBody {
            withdrawals: Some(Default::default()),
            ..Default::default()
        };

        assert!(
            consensus
                .validate_body_against_header(&body, &sealed)
                .is_ok()
        );
    }

    #[test]
    fn test_validate_block_pre_execution() {
        let consensus = TempoConsensus::new(MODERATO.clone());
        let chain_id = MODERATO.chain().id();

        let system_tx = create_system_tx(chain_id, SYSTEM_TX_ADDRESSES[0]);
        let user_tx = create_tx(chain_id);

        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(current_timestamp_millis())
            .build();
        let block = create_valid_block(header, vec![user_tx, system_tx]);
        let sealed = reth_primitives_traits::SealedBlock::seal_slow(block);

        assert!(consensus.validate_block_pre_execution(&sealed).is_ok());
    }

    #[test]
    fn test_validate_block_pre_execution_invalid_system_tx() {
        let consensus = TempoConsensus::new(MODERATO.clone());
        let chain_id = MODERATO.chain().id();

        let tx = TxLegacy {
            chain_id: Some(chain_id),
            nonce: 0,
            gas_price: 1_000_000_000,
            gas_limit: 21000,
            to: TxKind::Call(Address::ZERO),
            value: U256::ZERO,
            input: Default::default(),
        };
        let signature = Signature::new(U256::ZERO, U256::ZERO, false);
        let invalid_system_tx = TempoTxEnvelope::Legacy(Signed::new_unhashed(tx, signature));
        let tx_hash = *invalid_system_tx.tx_hash();

        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(current_timestamp_millis())
            .build();
        let block = create_valid_block(header, vec![invalid_system_tx]);
        let sealed = SealedBlock::seal_slow(block);

        let result = consensus.validate_block_pre_execution(&sealed);
        let err = result.unwrap_err();
        assert!(
            err.downcast_other_ref::<TempoConsensusError>()
                .is_some_and(
                    |e| matches!(e, TempoConsensusError::InvalidSystemTransaction { tx_hash: h } if *h == tx_hash)
                ),
            "Expected InvalidSystemTransaction, got: {err:?}"
        );
    }

    #[test]
    fn test_validate_block_pre_execution_pre_t4_missing_system_tx() {
        let consensus = TempoConsensus::new(MODERATO.clone());
        let chain_id = MODERATO.chain().id();

        let user_tx = create_tx(chain_id);

        use tempo_chainspec::constants::moderato::MODERATO_T4_TIMESTAMP;

        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(MODERATO_T4_TIMESTAMP - 1)
            .build();
        let block = create_valid_block(header, vec![user_tx]);
        let sealed = SealedBlock::seal_slow(block);

        let result = consensus.validate_block_pre_execution(&sealed);
        let err = result.unwrap_err();
        assert!(
            err.downcast_other_ref::<TempoConsensusError>()
                .is_some_and(|e| matches!(
                    e,
                    TempoConsensusError::MissingEndOfBlockSystemTxs { .. }
                )),
            "Expected MissingEndOfBlockSystemTxs, got: {err:?}"
        );
    }

    #[test]
    fn test_validate_block_pre_execution_t4_allows_missing_system_tx() {
        let consensus = TempoConsensus::new(DEV.clone());
        let chain_id = DEV.chain().id();

        let user_tx = create_tx(chain_id);

        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(0)
            .build();
        let block = create_valid_block(header, vec![user_tx]);
        let sealed = SealedBlock::seal_slow(block);

        assert!(consensus.validate_block_pre_execution(&sealed).is_ok());
    }

    #[test]
    fn test_validate_body_against_header_bad_tx_root() {
        let consensus = TempoConsensus::new(MODERATO.clone());
        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(current_timestamp_millis())
            .build();
        let sealed = SealedHeader::seal_slow(header);

        let chain_id = MODERATO.chain().id();
        let user_tx = create_tx(chain_id);
        let body = BlockBody {
            transactions: vec![user_tx],
            withdrawals: Some(Default::default()),
            ..Default::default()
        };

        let result = consensus.validate_body_against_header(&body, &sealed);
        assert!(
            matches!(result, Err(ConsensusError::BodyTransactionRootDiff(_))),
            "Expected BodyTransactionRootDiff error, got: {result:?}"
        );
    }

    #[test]
    fn test_validate_block_post_execution_bad_receipts() {
        let consensus = TempoConsensus::new(MODERATO.clone());
        let chain_id = MODERATO.chain().id();

        let system_tx = create_system_tx(chain_id, SYSTEM_TX_ADDRESSES[0]);
        let user_tx = create_tx(chain_id);

        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(current_timestamp_millis())
            .build();
        let block = create_valid_block(header, vec![user_tx, system_tx]);
        let recovered = RecoveredBlock::new_unhashed(block, vec![Address::ZERO, Address::ZERO]);

        let receipt = TempoReceipt {
            tx_type: tempo_primitives::TempoTxType::Legacy,
            success: true,
            cumulative_gas_used: 0,
            logs: vec![],
        };
        let result = BlockExecutionResult {
            receipts: vec![receipt],
            requests: Default::default(),
            gas_used: 0,
            blob_gas_used: 0,
        };

        let err = consensus
            .validate_block_post_execution(&recovered, &result, None, None)
            .unwrap_err();
        assert!(
            matches!(err, ConsensusError::BodyReceiptRootDiff(_)),
            "Expected BodyReceiptRootDiff error, got: {err:?}"
        );
    }

    #[test]
    fn test_validate_header_timestamp_exactly_at_boundary() {
        let consensus = TempoConsensus::new(MODERATO.clone());
        let boundary_timestamp = current_timestamp_millis() + ALLOWED_FUTURE_BLOCK_TIME_MILLIS;
        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp_millis(boundary_timestamp)
            .build();
        let sealed = SealedHeader::seal_slow(header);

        let result = consensus.validate_header(&sealed);
        assert!(
            result.is_ok(),
            "Timestamp exactly at boundary should be accepted, got: {result:?}"
        );
    }

    #[test]
    fn test_timestamp_in_future_is_transient_error() {
        let consensus = TempoConsensus::new(MODERATO.clone());
        let err = ConsensusError::TimestampIsInFuture {
            timestamp: 2,
            present_timestamp: 1,
        };

        assert!(Consensus::<Block>::is_transient_error(&consensus, &err));

        let err = ConsensusError::TimestampIsInPast {
            parent_timestamp: 2,
            timestamp: 1,
        };

        assert!(!Consensus::<Block>::is_transient_error(&consensus, &err));
    }

    #[test]
    fn test_validate_block_pre_execution_system_tx_out_of_order() {
        let consensus = TempoConsensus::new(MODERATO.clone());
        let chain_id = MODERATO.chain().id();

        let wrong_addr = Address::repeat_byte(0xFF);
        let system_tx = create_system_tx(chain_id, wrong_addr);

        use tempo_chainspec::constants::moderato::MODERATO_T4_TIMESTAMP;

        let header = TestHeaderBuilder::default()
            .gas_limit(30_000_000)
            .timestamp(MODERATO_T4_TIMESTAMP - 1)
            .build();
        let block = create_valid_block(header, vec![system_tx]);
        let sealed = SealedBlock::seal_slow(block);

        let result = consensus.validate_block_pre_execution(&sealed);
        let err = result.unwrap_err();
        assert!(
            err.downcast_other_ref::<TempoConsensusError>()
                .is_some_and(|e| matches!(
                    e,
                    TempoConsensusError::InvalidEndOfBlockSystemTxOrder { .. }
                )),
            "Expected InvalidEndOfBlockSystemTxOrder, got: {err:?}"
        );
    }
}