Ethereum Test Forks package

Ethereum test fork definitions.

ForkAttribute

Bases: Protocol

A protocol to get the attribute of a fork at a given block number and timestamp.

Source code in src/ethereum_test_forks/base_fork.py

class ForkAttribute(Protocol):
    """
    A protocol to get the attribute of a fork at a given block number and timestamp.
    """

    def __call__(self, block_number: int = 0, timestamp: int = 0) -> Any:
        """
        Returns the value of the attribute at the given block number and timestamp.
        """
        pass

__call__(block_number=0, timestamp=0)

Returns the value of the attribute at the given block number and timestamp.

Source code in src/ethereum_test_forks/base_fork.py

def __call__(self, block_number: int = 0, timestamp: int = 0) -> Any:
    """
    Returns the value of the attribute at the given block number and timestamp.
    """
    pass

ArrowGlacier

Bases: London

Arrow Glacier fork

Source code in src/ethereum_test_forks/forks/forks.py

class ArrowGlacier(London, solc_name="london", ignore=True):
    """
    Arrow Glacier fork
    """

    pass

Berlin

Bases: Istanbul

Berlin fork

Source code in src/ethereum_test_forks/forks/forks.py

class Berlin(Istanbul):
    """
    Berlin fork
    """

    @classmethod
    def tx_types(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
        """
        At Berlin, access list transactions are introduced
        """
        return [1] + super(Berlin, cls).tx_types(block_number, timestamp)

tx_types(block_number=0, timestamp=0) classmethod

At Berlin, access list transactions are introduced

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def tx_types(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
    """
    At Berlin, access list transactions are introduced
    """
    return [1] + super(Berlin, cls).tx_types(block_number, timestamp)

Byzantium

Bases: Homestead

Byzantium fork

Source code in src/ethereum_test_forks/forks/forks.py

class Byzantium(Homestead):
    """
    Byzantium fork
    """

    @classmethod
    def get_reward(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """
        At Byzantium, the block reward is reduced to
        3_000_000_000_000_000_000 wei
        """
        return 3_000_000_000_000_000_000

    @classmethod
    def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
        """
        At Byzantium, pre-compiles for bigint modular exponentiation, addition and scalar
        multiplication on elliptic curve alt_bn128, and optimal ate pairing check on
        elliptic curve alt_bn128 are introduced
        """
        return [5, 6, 7, 8] + super(Byzantium, cls).precompiles(block_number, timestamp)

get_reward(block_number=0, timestamp=0) classmethod

At Byzantium, the block reward is reduced to 3_000_000_000_000_000_000 wei

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def get_reward(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """
    At Byzantium, the block reward is reduced to
    3_000_000_000_000_000_000 wei
    """
    return 3_000_000_000_000_000_000

precompiles(block_number=0, timestamp=0) classmethod

At Byzantium, pre-compiles for bigint modular exponentiation, addition and scalar multiplication on elliptic curve alt_bn128, and optimal ate pairing check on elliptic curve alt_bn128 are introduced

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
    """
    At Byzantium, pre-compiles for bigint modular exponentiation, addition and scalar
    multiplication on elliptic curve alt_bn128, and optimal ate pairing check on
    elliptic curve alt_bn128 are introduced
    """
    return [5, 6, 7, 8] + super(Byzantium, cls).precompiles(block_number, timestamp)

Cancun

Bases: Shanghai

Cancun fork

Source code in src/ethereum_test_forks/forks/forks.py

class Cancun(Shanghai):
    """
    Cancun fork
    """

    @classmethod
    def is_deployed(cls):
        """
        Flags that Cancun has not been deployed to mainnet; it is under active
        development.
        """
        return False

    @classmethod
    def solc_min_version(cls) -> Version:
        """
        Returns the minimum version of solc that supports this fork.
        """
        return Version.parse("0.8.24")

    @classmethod
    def header_excess_blob_gas_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        Excess blob gas is required starting from Cancun.
        """
        return True

    @classmethod
    def header_blob_gas_used_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        Blob gas used is required starting from Cancun.
        """
        return True

    @classmethod
    def header_beacon_root_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        Parent beacon block root is required starting from Cancun.
        """
        return True

    @classmethod
    def blob_gas_per_blob(cls, block_number: int, timestamp: int) -> int:
        """
        Blobs are enabled started from Cancun.
        """
        return 2**17

    @classmethod
    def tx_types(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
        """
        At Cancun, blob type transactions are introduced
        """
        return [3] + super(Cancun, cls).tx_types(block_number, timestamp)

    @classmethod
    def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
        """
        At Cancun, pre-compile for kzg point evaluation is introduced
        """
        return [0xA] + super(Cancun, cls).precompiles(block_number, timestamp)

    @classmethod
    def pre_allocation_blockchain(cls) -> Mapping:
        """
        Cancun requires pre-allocation of the beacon root contract for EIP-4788 on blockchain
        type tests
        """
        new_allocation = {
            0x000F3DF6D732807EF1319FB7B8BB8522D0BEAC02: {
                "nonce": 1,
                "code": "0x3373fffffffffffffffffffffffffffffffffffffffe14604d57602036146024575f5f"
                "fd5b5f35801560495762001fff810690815414603c575f5ffd5b62001fff01545f5260205ff35b5f"
                "5ffd5b62001fff42064281555f359062001fff015500",
            }
        }
        return new_allocation | super(Cancun, cls).pre_allocation_blockchain()

    @classmethod
    def engine_new_payload_version(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> Optional[int]:
        """
        Starting at Cancun, new payload calls must use version 3
        """
        return 3

    @classmethod
    def engine_new_payload_blob_hashes(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        Starting at Cancun, payloads must have blob hashes.
        """
        return True

    @classmethod
    def engine_new_payload_beacon_root(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        Starting at Cancun, payloads must have a parent beacon block root.
        """
        return True

is_deployed() classmethod

Flags that Cancun has not been deployed to mainnet; it is under active development.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def is_deployed(cls):
    """
    Flags that Cancun has not been deployed to mainnet; it is under active
    development.
    """
    return False

solc_min_version() classmethod

Returns the minimum version of solc that supports this fork.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def solc_min_version(cls) -> Version:
    """
    Returns the minimum version of solc that supports this fork.
    """
    return Version.parse("0.8.24")

header_excess_blob_gas_required(block_number=0, timestamp=0) classmethod

Excess blob gas is required starting from Cancun.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_excess_blob_gas_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    Excess blob gas is required starting from Cancun.
    """
    return True

header_blob_gas_used_required(block_number=0, timestamp=0) classmethod

Blob gas used is required starting from Cancun.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_blob_gas_used_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    Blob gas used is required starting from Cancun.
    """
    return True

header_beacon_root_required(block_number=0, timestamp=0) classmethod

Parent beacon block root is required starting from Cancun.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_beacon_root_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    Parent beacon block root is required starting from Cancun.
    """
    return True

blob_gas_per_blob(block_number, timestamp) classmethod

Blobs are enabled started from Cancun.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def blob_gas_per_blob(cls, block_number: int, timestamp: int) -> int:
    """
    Blobs are enabled started from Cancun.
    """
    return 2**17

tx_types(block_number=0, timestamp=0) classmethod

At Cancun, blob type transactions are introduced

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def tx_types(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
    """
    At Cancun, blob type transactions are introduced
    """
    return [3] + super(Cancun, cls).tx_types(block_number, timestamp)

precompiles(block_number=0, timestamp=0) classmethod

At Cancun, pre-compile for kzg point evaluation is introduced

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
    """
    At Cancun, pre-compile for kzg point evaluation is introduced
    """
    return [0xA] + super(Cancun, cls).precompiles(block_number, timestamp)

pre_allocation_blockchain() classmethod

Cancun requires pre-allocation of the beacon root contract for EIP-4788 on blockchain type tests

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def pre_allocation_blockchain(cls) -> Mapping:
    """
    Cancun requires pre-allocation of the beacon root contract for EIP-4788 on blockchain
    type tests
    """
    new_allocation = {
        0x000F3DF6D732807EF1319FB7B8BB8522D0BEAC02: {
            "nonce": 1,
            "code": "0x3373fffffffffffffffffffffffffffffffffffffffe14604d57602036146024575f5f"
            "fd5b5f35801560495762001fff810690815414603c575f5ffd5b62001fff01545f5260205ff35b5f"
            "5ffd5b62001fff42064281555f359062001fff015500",
        }
    }
    return new_allocation | super(Cancun, cls).pre_allocation_blockchain()

engine_new_payload_version(block_number=0, timestamp=0) classmethod

Starting at Cancun, new payload calls must use version 3

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def engine_new_payload_version(
    cls, block_number: int = 0, timestamp: int = 0
) -> Optional[int]:
    """
    Starting at Cancun, new payload calls must use version 3
    """
    return 3

engine_new_payload_blob_hashes(block_number=0, timestamp=0) classmethod

Starting at Cancun, payloads must have blob hashes.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def engine_new_payload_blob_hashes(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    Starting at Cancun, payloads must have blob hashes.
    """
    return True

engine_new_payload_beacon_root(block_number=0, timestamp=0) classmethod

Starting at Cancun, payloads must have a parent beacon block root.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def engine_new_payload_beacon_root(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    Starting at Cancun, payloads must have a parent beacon block root.
    """
    return True

Constantinople

Bases: Byzantium

Constantinople fork

Source code in src/ethereum_test_forks/forks/forks.py

class Constantinople(Byzantium):
    """
    Constantinople fork
    """

    @classmethod
    def get_reward(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """
        At Constantinople, the block reward is reduced to
        2_000_000_000_000_000_000 wei
        """
        return 2_000_000_000_000_000_000

get_reward(block_number=0, timestamp=0) classmethod

At Constantinople, the block reward is reduced to 2_000_000_000_000_000_000 wei

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def get_reward(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """
    At Constantinople, the block reward is reduced to
    2_000_000_000_000_000_000 wei
    """
    return 2_000_000_000_000_000_000

ConstantinopleFix

Bases: Constantinople

Constantinople Fix fork

Source code in src/ethereum_test_forks/forks/forks.py

class ConstantinopleFix(Constantinople, solc_name="constantinople"):
    """
    Constantinople Fix fork
    """

    pass

Frontier

Bases: BaseFork

Frontier fork

Source code in src/ethereum_test_forks/forks/forks.py

class Frontier(BaseFork, solc_name="homestead"):
    """
    Frontier fork
    """

    @classmethod
    def transition_tool_name(cls, block_number: int = 0, timestamp: int = 0) -> str:
        """
        Returns fork name as it's meant to be passed to the transition tool for execution.
        """
        if cls._transition_tool_name is not None:
            return cls._transition_tool_name
        return cls.name()

    @classmethod
    def solc_name(cls) -> str:
        """
        Returns fork name as it's meant to be passed to the solc compiler.
        """
        if cls._solc_name is not None:
            return cls._solc_name
        return cls.name().lower()

    @classmethod
    def solc_min_version(cls) -> Version:
        """
        Returns the minimum version of solc that supports this fork.
        """
        return Version.parse("0.8.20")

    @classmethod
    def header_base_fee_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        At genesis, header must not contain base fee
        """
        return False

    @classmethod
    def header_prev_randao_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        At genesis, header must not contain Prev Randao value
        """
        return False

    @classmethod
    def header_zero_difficulty_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        At genesis, header must not have difficulty zero
        """
        return False

    @classmethod
    def header_withdrawals_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        At genesis, header must not contain withdrawals
        """
        return False

    @classmethod
    def header_excess_blob_gas_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        At genesis, header must not contain excess blob gas
        """
        return False

    @classmethod
    def header_blob_gas_used_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        At genesis, header must not contain blob gas used
        """
        return False

    @classmethod
    def blob_gas_per_blob(cls, block_number: int, timestamp: int) -> int:
        """
        Returns the amount of blob gas used per blob for a given fork.
        """
        return 0

    @classmethod
    def engine_new_payload_version(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> Optional[int]:
        """
        At genesis, payloads cannot be sent through the engine API
        """
        return None

    @classmethod
    def header_beacon_root_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        At genesis, header must not contain parent beacon block root
        """
        return False

    @classmethod
    def engine_new_payload_blob_hashes(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        At genesis, payloads do not have blob hashes.
        """
        return False

    @classmethod
    def engine_new_payload_beacon_root(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        At genesis, payloads do not have a parent beacon block root.
        """
        return False

    @classmethod
    def engine_forkchoice_updated_version(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> Optional[int]:
        """
        At genesis, forkchoice updates cannot be sent through the engine API.
        """
        return cls.engine_new_payload_version(block_number, timestamp)

    @classmethod
    def get_reward(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """
        At Genesis the expected reward amount in wei is
        5_000_000_000_000_000_000
        """
        return 5_000_000_000_000_000_000

    @classmethod
    def tx_types(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
        """
        At Genesis, only legacy transactions are allowed
        """
        return [0]

    @classmethod
    def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
        """
        At Genesis, no pre-compiles are allowed
        """
        return []

    @classmethod
    def pre_allocation(cls) -> Mapping:
        """
        Returns whether the fork expects pre-allocation of accounts

        Frontier does not require pre-allocated accounts
        """
        return {}

    @classmethod
    def pre_allocation_blockchain(cls) -> Mapping:
        """
        Returns whether the fork expects pre-allocation of accounts

        Frontier does not require pre-allocated accounts
        """
        return {}

transition_tool_name(block_number=0, timestamp=0) classmethod

Returns fork name as it's meant to be passed to the transition tool for execution.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def transition_tool_name(cls, block_number: int = 0, timestamp: int = 0) -> str:
    """
    Returns fork name as it's meant to be passed to the transition tool for execution.
    """
    if cls._transition_tool_name is not None:
        return cls._transition_tool_name
    return cls.name()

solc_name() classmethod

Returns fork name as it's meant to be passed to the solc compiler.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def solc_name(cls) -> str:
    """
    Returns fork name as it's meant to be passed to the solc compiler.
    """
    if cls._solc_name is not None:
        return cls._solc_name
    return cls.name().lower()

solc_min_version() classmethod

Returns the minimum version of solc that supports this fork.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def solc_min_version(cls) -> Version:
    """
    Returns the minimum version of solc that supports this fork.
    """
    return Version.parse("0.8.20")

header_base_fee_required(block_number=0, timestamp=0) classmethod

At genesis, header must not contain base fee

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_base_fee_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    At genesis, header must not contain base fee
    """
    return False

header_prev_randao_required(block_number=0, timestamp=0) classmethod

At genesis, header must not contain Prev Randao value

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_prev_randao_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    At genesis, header must not contain Prev Randao value
    """
    return False

header_zero_difficulty_required(block_number=0, timestamp=0) classmethod

At genesis, header must not have difficulty zero

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_zero_difficulty_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    At genesis, header must not have difficulty zero
    """
    return False

header_withdrawals_required(block_number=0, timestamp=0) classmethod

At genesis, header must not contain withdrawals

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_withdrawals_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    At genesis, header must not contain withdrawals
    """
    return False

header_excess_blob_gas_required(block_number=0, timestamp=0) classmethod

At genesis, header must not contain excess blob gas

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_excess_blob_gas_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    At genesis, header must not contain excess blob gas
    """
    return False

header_blob_gas_used_required(block_number=0, timestamp=0) classmethod

At genesis, header must not contain blob gas used

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_blob_gas_used_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    At genesis, header must not contain blob gas used
    """
    return False

blob_gas_per_blob(block_number, timestamp) classmethod

Returns the amount of blob gas used per blob for a given fork.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def blob_gas_per_blob(cls, block_number: int, timestamp: int) -> int:
    """
    Returns the amount of blob gas used per blob for a given fork.
    """
    return 0

engine_new_payload_version(block_number=0, timestamp=0) classmethod

At genesis, payloads cannot be sent through the engine API

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def engine_new_payload_version(
    cls, block_number: int = 0, timestamp: int = 0
) -> Optional[int]:
    """
    At genesis, payloads cannot be sent through the engine API
    """
    return None

header_beacon_root_required(block_number=0, timestamp=0) classmethod

At genesis, header must not contain parent beacon block root

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_beacon_root_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    At genesis, header must not contain parent beacon block root
    """
    return False

engine_new_payload_blob_hashes(block_number=0, timestamp=0) classmethod

At genesis, payloads do not have blob hashes.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def engine_new_payload_blob_hashes(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    At genesis, payloads do not have blob hashes.
    """
    return False

engine_new_payload_beacon_root(block_number=0, timestamp=0) classmethod

At genesis, payloads do not have a parent beacon block root.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def engine_new_payload_beacon_root(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    At genesis, payloads do not have a parent beacon block root.
    """
    return False

engine_forkchoice_updated_version(block_number=0, timestamp=0) classmethod

At genesis, forkchoice updates cannot be sent through the engine API.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def engine_forkchoice_updated_version(
    cls, block_number: int = 0, timestamp: int = 0
) -> Optional[int]:
    """
    At genesis, forkchoice updates cannot be sent through the engine API.
    """
    return cls.engine_new_payload_version(block_number, timestamp)

get_reward(block_number=0, timestamp=0) classmethod

At Genesis the expected reward amount in wei is 5_000_000_000_000_000_000

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def get_reward(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """
    At Genesis the expected reward amount in wei is
    5_000_000_000_000_000_000
    """
    return 5_000_000_000_000_000_000

tx_types(block_number=0, timestamp=0) classmethod

At Genesis, only legacy transactions are allowed

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def tx_types(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
    """
    At Genesis, only legacy transactions are allowed
    """
    return [0]

precompiles(block_number=0, timestamp=0) classmethod

At Genesis, no pre-compiles are allowed

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
    """
    At Genesis, no pre-compiles are allowed
    """
    return []

pre_allocation() classmethod

Returns whether the fork expects pre-allocation of accounts

Frontier does not require pre-allocated accounts

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def pre_allocation(cls) -> Mapping:
    """
    Returns whether the fork expects pre-allocation of accounts

    Frontier does not require pre-allocated accounts
    """
    return {}

pre_allocation_blockchain() classmethod

Returns whether the fork expects pre-allocation of accounts

Frontier does not require pre-allocated accounts

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def pre_allocation_blockchain(cls) -> Mapping:
    """
    Returns whether the fork expects pre-allocation of accounts

    Frontier does not require pre-allocated accounts
    """
    return {}

GrayGlacier

Bases: ArrowGlacier

Gray Glacier fork

Source code in src/ethereum_test_forks/forks/forks.py

class GrayGlacier(ArrowGlacier, solc_name="london", ignore=True):
    """
    Gray Glacier fork
    """

    pass

Homestead

Bases: Frontier

Homestead fork

Source code in src/ethereum_test_forks/forks/forks.py

class Homestead(Frontier):
    """
    Homestead fork
    """

    @classmethod
    def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
        """
        At Homestead, EC-recover, SHA256, RIPEMD160, and Identity pre-compiles are introduced
        """
        return [1, 2, 3, 4] + super(Homestead, cls).precompiles(block_number, timestamp)

precompiles(block_number=0, timestamp=0) classmethod

At Homestead, EC-recover, SHA256, RIPEMD160, and Identity pre-compiles are introduced

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
    """
    At Homestead, EC-recover, SHA256, RIPEMD160, and Identity pre-compiles are introduced
    """
    return [1, 2, 3, 4] + super(Homestead, cls).precompiles(block_number, timestamp)

Istanbul

Bases: ConstantinopleFix

Istanbul fork

Source code in src/ethereum_test_forks/forks/forks.py

class Istanbul(ConstantinopleFix):
    """
    Istanbul fork
    """

    @classmethod
    def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
        """
        At Istanbul, pre-compile for blake2 compression is introduced
        """
        return [9] + super(Istanbul, cls).precompiles(block_number, timestamp)

precompiles(block_number=0, timestamp=0) classmethod

At Istanbul, pre-compile for blake2 compression is introduced

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
    """
    At Istanbul, pre-compile for blake2 compression is introduced
    """
    return [9] + super(Istanbul, cls).precompiles(block_number, timestamp)

London

Bases: Berlin

London fork

Source code in src/ethereum_test_forks/forks/forks.py

class London(Berlin):
    """
    London fork
    """

    @classmethod
    def header_base_fee_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        Base Fee is required starting from London.
        """
        return True

    @classmethod
    def tx_types(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
        """
        At London, dynamic fee transactions are introduced
        """
        return [2] + super(London, cls).tx_types(block_number, timestamp)

header_base_fee_required(block_number=0, timestamp=0) classmethod

Base Fee is required starting from London.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_base_fee_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    Base Fee is required starting from London.
    """
    return True

tx_types(block_number=0, timestamp=0) classmethod

At London, dynamic fee transactions are introduced

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def tx_types(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
    """
    At London, dynamic fee transactions are introduced
    """
    return [2] + super(London, cls).tx_types(block_number, timestamp)

MuirGlacier

Bases: Istanbul

Muir Glacier fork

Source code in src/ethereum_test_forks/forks/forks.py

class MuirGlacier(Istanbul, solc_name="istanbul", ignore=True):
    """
    Muir Glacier fork
    """

    pass

Paris

Bases: London

Paris (Merge) fork

Source code in src/ethereum_test_forks/forks/forks.py

class Paris(
    London,
    transition_tool_name="Merge",
    blockchain_test_network_name="Merge",
):
    """
    Paris (Merge) fork
    """

    @classmethod
    def header_prev_randao_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        Prev Randao is required starting from Paris.
        """
        return True

    @classmethod
    def header_zero_difficulty_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        Zero difficulty is required starting from Paris.
        """
        return True

    @classmethod
    def get_reward(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """
        Paris updates the reward to 0.
        """
        return 0

    @classmethod
    def engine_new_payload_version(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> Optional[int]:
        """
        Starting at Paris, payloads can be sent through the engine API
        """
        return 1

header_prev_randao_required(block_number=0, timestamp=0) classmethod

Prev Randao is required starting from Paris.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_prev_randao_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    Prev Randao is required starting from Paris.
    """
    return True

header_zero_difficulty_required(block_number=0, timestamp=0) classmethod

Zero difficulty is required starting from Paris.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_zero_difficulty_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    Zero difficulty is required starting from Paris.
    """
    return True

get_reward(block_number=0, timestamp=0) classmethod

Paris updates the reward to 0.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def get_reward(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """
    Paris updates the reward to 0.
    """
    return 0

engine_new_payload_version(block_number=0, timestamp=0) classmethod

Starting at Paris, payloads can be sent through the engine API

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def engine_new_payload_version(
    cls, block_number: int = 0, timestamp: int = 0
) -> Optional[int]:
    """
    Starting at Paris, payloads can be sent through the engine API
    """
    return 1

Shanghai

Bases: Paris

Shanghai fork

Source code in src/ethereum_test_forks/forks/forks.py

class Shanghai(Paris):
    """
    Shanghai fork
    """

    @classmethod
    def header_withdrawals_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        Withdrawals are required starting from Shanghai.
        """
        return True

    @classmethod
    def engine_new_payload_version(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> Optional[int]:
        """
        Starting at Shanghai, new payload calls must use version 2
        """
        return 2

header_withdrawals_required(block_number=0, timestamp=0) classmethod

Withdrawals are required starting from Shanghai.

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def header_withdrawals_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    Withdrawals are required starting from Shanghai.
    """
    return True

engine_new_payload_version(block_number=0, timestamp=0) classmethod

Starting at Shanghai, new payload calls must use version 2

Source code in src/ethereum_test_forks/forks/forks.py

@classmethod
def engine_new_payload_version(
    cls, block_number: int = 0, timestamp: int = 0
) -> Optional[int]:
    """
    Starting at Shanghai, new payload calls must use version 2
    """
    return 2

BerlinToLondonAt5

Bases: Berlin

Berlin to London transition at Block 5

Source code in src/ethereum_test_forks/forks/transition.py

@transition_fork(to_fork=London, at_block=5)
class BerlinToLondonAt5(Berlin):
    """
    Berlin to London transition at Block 5
    """

    pass

ParisToShanghaiAtTime15k

Bases: Paris

Paris to Shanghai transition at Timestamp 15k

Source code in src/ethereum_test_forks/forks/transition.py

@transition_fork(to_fork=Shanghai, at_timestamp=15_000)
class ParisToShanghaiAtTime15k(Paris, blockchain_test_network_name="ParisToShanghaiAtTime15k"):
    """
    Paris to Shanghai transition at Timestamp 15k
    """

    pass

ShanghaiToCancunAtTime15k

Bases: Shanghai

Shanghai to Cancun transition at Timestamp 15k

Source code in src/ethereum_test_forks/forks/transition.py

@transition_fork(to_fork=Cancun, at_timestamp=15_000)
class ShanghaiToCancunAtTime15k(Shanghai):
    """
    Shanghai to Cancun transition at Timestamp 15k
    """

    pass

InvalidForkError

Bases: Exception

Invalid fork error raised when the fork specified by command-line option --latest-fork is not found.

Source code in src/ethereum_test_forks/helpers.py

class InvalidForkError(Exception):
    """
    Invalid fork error raised when the fork specified by command-line option
    --latest-fork is not found.
    """

    def __init__(self, message):
        super().__init__(message)

forks_from(fork, deployed_only=True)

Returns the specified fork and all forks after it.

Source code in src/ethereum_test_forks/helpers.py

def forks_from(fork: Fork, deployed_only: bool = True) -> List[Fork]:
    """
    Returns the specified fork and all forks after it.
    """
    if deployed_only:
        latest_fork = get_deployed_forks()[-1]
    else:
        latest_fork = get_forks()[-1]
    return forks_from_until(fork, latest_fork)

forks_from_until(fork_from, fork_until)

Returns the specified fork and all forks after it until and including the second specified fork

Source code in src/ethereum_test_forks/helpers.py

def forks_from_until(fork_from: Fork, fork_until: Fork) -> List[Fork]:
    """
    Returns the specified fork and all forks after it until and including the
    second specified fork
    """
    prev_fork = fork_until

    forks: List[Fork] = []

    while prev_fork != BaseFork and prev_fork != fork_from:
        forks.insert(0, prev_fork)

        prev_fork = prev_fork.__base__

    if prev_fork == BaseFork:
        return []

    forks.insert(0, fork_from)

    return forks

get_closest_fork_with_solc_support(fork, solc_version)

Returns the closest fork, potentially the provided fork itself, that has solc support.

Source code in src/ethereum_test_forks/helpers.py

def get_closest_fork_with_solc_support(fork: Fork, solc_version: Version) -> Optional[Fork]:
    """
    Returns the closest fork, potentially the provided fork itself, that has
    solc support.
    """
    if fork is BaseFork:
        return None
    return (
        fork
        if solc_version >= fork.solc_min_version()
        else get_closest_fork_with_solc_support(get_parent_fork(fork), solc_version)
    )

get_deployed_forks()

Returns a list of all the fork classes implemented by ethereum_test_forks that have been deployed to mainnet, chronologically ordered by deployment.

Source code in src/ethereum_test_forks/helpers.py

def get_deployed_forks() -> List[Fork]:
    """
    Returns a list of all the fork classes implemented by `ethereum_test_forks`
    that have been deployed to mainnet, chronologically ordered by deployment.
    """
    return [fork for fork in get_forks() if fork.is_deployed()]

get_development_forks()

Returns a list of all the fork classes implemented by ethereum_test_forks that have been not yet deployed to mainnet and are currently under development. The list is ordered by their planned deployment date.

Source code in src/ethereum_test_forks/helpers.py

def get_development_forks() -> List[Fork]:
    """
    Returns a list of all the fork classes implemented by `ethereum_test_forks`
    that have been not yet deployed to mainnet and are currently under
    development. The list is ordered by their planned deployment date.
    """
    return [fork for fork in get_forks() if not fork.is_deployed()]

get_forks()

Returns a list of all the fork classes implemented by ethereum_test_forks ordered chronologically by deployment.

Source code in src/ethereum_test_forks/helpers.py

def get_forks() -> List[Fork]:
    """
    Returns a list of all the fork classes implemented by
    `ethereum_test_forks` ordered chronologically by deployment.
    """
    all_forks: List[Fork] = []
    for fork_name in forks.__dict__:
        fork = forks.__dict__[fork_name]
        if not isinstance(fork, type):
            continue
        if issubclass(fork, BaseFork) and fork is not BaseFork:
            all_forks.append(fork)
    return all_forks

get_forks_with_solc_support(solc_version)

Returns a list of all fork classes that are supported by solc.

Source code in src/ethereum_test_forks/helpers.py

def get_forks_with_solc_support(solc_version: Version) -> List[Fork]:
    """
    Returns a list of all fork classes that are supported by solc.
    """
    return [fork for fork in get_forks() if solc_version >= fork.solc_min_version()]

get_forks_without_solc_support(solc_version)

Returns a list of all fork classes that aren't supported by solc.

Source code in src/ethereum_test_forks/helpers.py

def get_forks_without_solc_support(solc_version: Version) -> List[Fork]:
    """
    Returns a list of all fork classes that aren't supported by solc.
    """
    return [fork for fork in get_forks() if solc_version < fork.solc_min_version()]

get_transition_forks()

Returns all the transition forks

Source code in src/ethereum_test_forks/helpers.py

def get_transition_forks() -> List[Fork]:
    """
    Returns all the transition forks
    """
    transition_forks: List[Fork] = []

    for fork_name in transition.__dict__:
        fork = transition.__dict__[fork_name]
        if not isinstance(fork, type):
            continue
        if issubclass(fork, TransitionBaseClass) and issubclass(fork, BaseFork):
            transition_forks.append(fork)

    return transition_forks

transition_fork_from_to(fork_from, fork_to)

Returns the transition fork that transitions to and from the specified forks.

Source code in src/ethereum_test_forks/helpers.py

def transition_fork_from_to(fork_from: Fork, fork_to: Fork) -> Fork | None:
    """
    Returns the transition fork that transitions to and from the specified
    forks.
    """
    for transition_fork in get_transition_forks():
        if not issubclass(transition_fork, TransitionBaseClass):
            continue
        if (
            transition_fork.transitions_to() == fork_to
            and transition_fork.transitions_from() == fork_from
        ):
            return transition_fork

    return None

transition_fork_to(fork_to)

Returns the transition fork that transitions to the specified fork.

Source code in src/ethereum_test_forks/helpers.py

def transition_fork_to(fork_to: Fork) -> List[Fork]:
    """
    Returns the transition fork that transitions to the specified fork.
    """
    transition_forks: List[Fork] = []
    for transition_fork in get_transition_forks():
        if not issubclass(transition_fork, TransitionBaseClass):
            continue
        if transition_fork.transitions_to() == fork_to:
            transition_forks.append(transition_fork)

    return transition_forks