Enum ForkCondition

pub enum ForkCondition {
    Block(u64),
    TTD {
        activation_block_number: u64,
        fork_block: Option<u64>,
        total_difficulty: Uint<256, 4>,
    },
    Timestamp(u64),
    Never,
}

The condition at which a fork is activated.

Variants

Block(u64)

The fork is activated after a certain block.

TTD

The fork is activated after a total difficulty has been reached.

Fields

activation_block_number: u64

The activation block number for the merge.

This should represent the first post-merge block for the given network. Sepolia and mainnet are the only networks that have merged, and they have both finalized post-merge, so total difficulty is effectively deprecated.

fork_block: Option<u64>

The block number at which TTD is reached, if it is known.

This should NOT be set unless you want this block advertised as EIP-2124 FORK_NEXT. This is currently only the case for Sepolia and Holesky.

total_difficulty: Uint<256, 4>

The total difficulty after which the fork is activated.

Timestamp(u64)

The fork is activated after a specific timestamp.

Never

The fork is never activated

Implementations

impl ForkCondition

pub const fn is_timestamp(&self) -> bool

Returns true if the fork condition is timestamp based.

pub const fn active_at_block(&self, current_block: u64) -> bool

Checks whether the fork condition is satisfied at the given block.

This will return true if the block number is equal or greater than the activation block of:

• ForkCondition::Block
• ForkCondition::TTD

For timestamp conditions, this will always return false.

pub const fn transitions_at_block(&self, current_block: u64) -> bool

Checks if the given block is the first block that satisfies the fork condition.

This will return false for any condition that is not block based.

pub fn active_at_ttd(&self, ttd: Uint<256, 4>, difficulty: Uint<256, 4>) -> bool

Checks whether the fork condition is satisfied at the given total difficulty and difficulty of a current block.

The fork is considered active if the previous total difficulty is above the threshold. To achieve that, we subtract the passed difficulty from the current block’s total difficulty, and check if it’s above the Fork Condition’s total difficulty (here: 58_750_000_000_000_000_000_000)

This will return false for any condition that is not TTD-based.

pub const fn active_at_timestamp(&self, timestamp: u64) -> bool

Checks whether the fork condition is satisfied at the given timestamp.

This will return false for any condition that is not timestamp-based.

pub const fn transitions_at_timestamp( &self, timestamp: u64, parent_timestamp: u64, ) -> bool

Checks if the given block is the first block that satisfies the fork condition.

This will return false for any condition that is not timestamp based.

pub const fn active_at_timestamp_or_number( &self, timestamp: u64, block_number: u64, ) -> bool

Checks whether the fork condition is satisfied at the given timestamp or number.

pub fn active_at_head(&self, head: &Head) -> bool

Checks whether the fork condition is satisfied at the given head block.

This will return true if:

• The condition is satisfied by the block number;
• The condition is satisfied by the timestamp;
• or the condition is satisfied by the total difficulty

pub const fn ttd(&self) -> Option<Uint<256, 4>>

Get the total terminal difficulty for this fork condition.

Returns None for fork conditions that are not TTD based.

pub const fn as_timestamp(&self) -> Option<u64>

Returns the timestamp of the fork condition, if it is timestamp based.

Trait Implementations

impl Clone for ForkCondition

fn clone(&self) -> ForkCondition

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ForkCondition

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for ForkCondition

fn default() -> ForkCondition

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ForkCondition

fn deserialize<__D>( __deserializer: __D, ) -> Result<ForkCondition, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ForkCondition

fn eq(&self, other: &ForkCondition) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ForkCondition

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ForkCondition

impl Eq for ForkCondition

impl StructuralPartialEq for ForkCondition

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 56 bytes

Size for each variant:

• Block: 16 bytes
• TTD: 56 bytes
• Timestamp: 16 bytes
• Never: 0 bytes