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)

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

    @classmethod
    def transaction_intrinsic_cost_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> TransactionIntrinsicCostCalculator:
        """
        At Berlin, the transaction intrinsic cost needs to take the access list into account
        """
        super_fn = super(Berlin, cls).transaction_intrinsic_cost_calculator(
            block_number, timestamp
        )
        gas_costs = cls.gas_costs(block_number, timestamp)

        def fn(
            *,
            calldata: BytesConvertible = b"",
            contract_creation: bool = False,
            access_list: List[AccessList] | None = None,
            authorization_list_or_count: Sized | int | None = None,
            return_cost_deducted_prior_execution: bool = False,
        ) -> int:
            intrinsic_cost: int = super_fn(
                calldata=calldata,
                contract_creation=contract_creation,
                authorization_list_or_count=authorization_list_or_count,
            )
            if access_list is not None:
                for access in access_list:
                    intrinsic_cost += gas_costs.G_ACCESS_LIST_ADDRESS
                    for _ in access.storage_keys:
                        intrinsic_cost += gas_costs.G_ACCESS_LIST_STORAGE
            return intrinsic_cost

        return fn

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)

contract_creating_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 contract_creating_tx_types(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
    """
    At Berlin, access list transactions are introduced
    """
    return [1] + super(Berlin, cls).contract_creating_tx_types(block_number, timestamp)

transaction_intrinsic_cost_calculator(block_number=0, timestamp=0) classmethod

At Berlin, the transaction intrinsic cost needs to take the access list into account

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

@classmethod
def transaction_intrinsic_cost_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> TransactionIntrinsicCostCalculator:
    """
    At Berlin, the transaction intrinsic cost needs to take the access list into account
    """
    super_fn = super(Berlin, cls).transaction_intrinsic_cost_calculator(
        block_number, timestamp
    )
    gas_costs = cls.gas_costs(block_number, timestamp)

    def fn(
        *,
        calldata: BytesConvertible = b"",
        contract_creation: bool = False,
        access_list: List[AccessList] | None = None,
        authorization_list_or_count: Sized | int | None = None,
        return_cost_deducted_prior_execution: bool = False,
    ) -> int:
        intrinsic_cost: int = super_fn(
            calldata=calldata,
            contract_creation=contract_creation,
            authorization_list_or_count=authorization_list_or_count,
        )
        if access_list is not None:
            for access in access_list:
                intrinsic_cost += gas_costs.G_ACCESS_LIST_ADDRESS
                for _ in access.storage_keys:
                    intrinsic_cost += gas_costs.G_ACCESS_LIST_STORAGE
        return intrinsic_cost

    return fn

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[Address]:
        """
        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 list(Address(i) for i in range(5, 9)) + super(Byzantium, cls).precompiles(
            block_number, timestamp
        )

    @classmethod
    def call_opcodes(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> List[Tuple[Opcodes, EVMCodeType]]:
        """
        At Byzantium, STATICCALL opcode was introduced.
        """
        return [(Opcodes.STATICCALL, EVMCodeType.LEGACY)] + super(Byzantium, cls).call_opcodes(
            block_number, timestamp
        )

    @classmethod
    def valid_opcodes(
        cls,
    ) -> List[Opcodes]:
        """
        Returns the list of Opcodes that are valid to work on this fork.
        """
        return [Opcodes.RETURNDATASIZE, Opcodes.STATICCALL] + super(Byzantium, cls).valid_opcodes()

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[Address]:
    """
    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 list(Address(i) for i in range(5, 9)) + super(Byzantium, cls).precompiles(
        block_number, timestamp
    )

call_opcodes(block_number=0, timestamp=0) classmethod

At Byzantium, STATICCALL opcode was introduced.

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

@classmethod
def call_opcodes(
    cls, block_number: int = 0, timestamp: int = 0
) -> List[Tuple[Opcodes, EVMCodeType]]:
    """
    At Byzantium, STATICCALL opcode was introduced.
    """
    return [(Opcodes.STATICCALL, EVMCodeType.LEGACY)] + super(Byzantium, cls).call_opcodes(
        block_number, timestamp
    )

valid_opcodes() classmethod

Returns the list of Opcodes that are valid to work on this fork.

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

@classmethod
def valid_opcodes(
    cls,
) -> List[Opcodes]:
    """
    Returns the list of Opcodes that are valid to work on this fork.
    """
    return [Opcodes.RETURNDATASIZE, Opcodes.STATICCALL] + super(Byzantium, cls).valid_opcodes()

Cancun

Bases: Shanghai

Cancun fork

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

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

    @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 starting from Cancun.
        """
        return 2**17

    @classmethod
    def target_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
        """
        Blobs are enabled starting from Cancun, with a static target of 3 blobs.
        """
        return 3

    @classmethod
    def max_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
        """
        Blobs are enabled starting from Cancun, with a static max of 6 blobs.
        """
        return 6

    @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[Address]:
        """
        At Cancun, pre-compile for kzg point evaluation is introduced
        """
        return [Address(0xA)] + super(Cancun, cls).precompiles(block_number, timestamp)

    @classmethod
    def system_contracts(cls, block_number: int = 0, timestamp: int = 0) -> List[Address]:
        """
        Cancun introduces the system contract for EIP-4788
        """
        return [Address(0x000F3DF6D732807EF1319FB7B8BB8522D0BEAC02)]

    @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()  # type: ignore

    @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

    @classmethod
    def valid_opcodes(
        cls,
    ) -> List[Opcodes]:
        """
        Returns the list of Opcodes that are valid to work on this fork.
        """
        return [
            Opcodes.BLOBHASH,
            Opcodes.BLOBBASEFEE,
            Opcodes.TLOAD,
            Opcodes.TSTORE,
            Opcodes.MCOPY,
        ] + super(Cancun, cls).valid_opcodes()

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 starting 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 starting from Cancun.
    """
    return 2**17

target_blobs_per_block(block_number, timestamp) classmethod

Blobs are enabled starting from Cancun, with a static target of 3 blobs.

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

@classmethod
def target_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
    """
    Blobs are enabled starting from Cancun, with a static target of 3 blobs.
    """
    return 3

max_blobs_per_block(block_number, timestamp) classmethod

Blobs are enabled starting from Cancun, with a static max of 6 blobs.

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

@classmethod
def max_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
    """
    Blobs are enabled starting from Cancun, with a static max of 6 blobs.
    """
    return 6

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[Address]:
    """
    At Cancun, pre-compile for kzg point evaluation is introduced
    """
    return [Address(0xA)] + super(Cancun, cls).precompiles(block_number, timestamp)

system_contracts(block_number=0, timestamp=0) classmethod

Cancun introduces the system contract for EIP-4788

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

@classmethod
def system_contracts(cls, block_number: int = 0, timestamp: int = 0) -> List[Address]:
    """
    Cancun introduces the system contract for EIP-4788
    """
    return [Address(0x000F3DF6D732807EF1319FB7B8BB8522D0BEAC02)]

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()  # type: ignore

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

valid_opcodes() classmethod

Returns the list of Opcodes that are valid to work on this fork.

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

@classmethod
def valid_opcodes(
    cls,
) -> List[Opcodes]:
    """
    Returns the list of Opcodes that are valid to work on this fork.
    """
    return [
        Opcodes.BLOBHASH,
        Opcodes.BLOBBASEFEE,
        Opcodes.TLOAD,
        Opcodes.TSTORE,
        Opcodes.MCOPY,
    ] + super(Cancun, cls).valid_opcodes()

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

    @classmethod
    def create_opcodes(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> List[Tuple[Opcodes, EVMCodeType]]:
        """
        At Constantinople, `CREATE2` opcode is added.
        """
        return [(Opcodes.CREATE2, EVMCodeType.LEGACY)] + super(Constantinople, cls).create_opcodes(
            block_number, timestamp
        )

    @classmethod
    def valid_opcodes(
        cls,
    ) -> List[Opcodes]:
        """
        Returns the list of Opcodes that are valid to work on this fork.
        """
        return [
            Opcodes.SHL,
            Opcodes.SHR,
            Opcodes.SAR,
            Opcodes.EXTCODEHASH,
            Opcodes.CREATE2,
        ] + super(Constantinople, cls).valid_opcodes()

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

create_opcodes(block_number=0, timestamp=0) classmethod

At Constantinople, CREATE2 opcode is added.

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

@classmethod
def create_opcodes(
    cls, block_number: int = 0, timestamp: int = 0
) -> List[Tuple[Opcodes, EVMCodeType]]:
    """
    At Constantinople, `CREATE2` opcode is added.
    """
    return [(Opcodes.CREATE2, EVMCodeType.LEGACY)] + super(Constantinople, cls).create_opcodes(
        block_number, timestamp
    )

valid_opcodes() classmethod

Returns the list of Opcodes that are valid to work on this fork.

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

@classmethod
def valid_opcodes(
    cls,
) -> List[Opcodes]:
    """
    Returns the list of Opcodes that are valid to work on this fork.
    """
    return [
        Opcodes.SHL,
        Opcodes.SHR,
        Opcodes.SAR,
        Opcodes.EXTCODEHASH,
        Opcodes.CREATE2,
    ] + super(Constantinople, cls).valid_opcodes()

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 gas_costs(cls, block_number: int = 0, timestamp: int = 0) -> GasCosts:
        """
        Returns a dataclass with the defined gas costs constants for genesis.
        """
        return GasCosts(
            G_JUMPDEST=1,
            G_BASE=2,
            G_VERY_LOW=3,
            G_LOW=5,
            G_MID=8,
            G_HIGH=10,
            G_WARM_ACCOUNT_ACCESS=100,
            G_COLD_ACCOUNT_ACCESS=2_600,
            G_ACCESS_LIST_ADDRESS=2_400,
            G_ACCESS_LIST_STORAGE=1_900,
            G_WARM_SLOAD=100,
            G_COLD_SLOAD=2_100,
            G_STORAGE_SET=20_000,
            G_STORAGE_RESET=2_900,
            R_STORAGE_CLEAR=4_800,
            G_SELF_DESTRUCT=5_000,
            G_CREATE=32_000,
            G_CODE_DEPOSIT_BYTE=200,
            G_INITCODE_WORD=2,
            G_CALL_VALUE=9_000,
            G_CALL_STIPEND=2_300,
            G_NEW_ACCOUNT=25_000,
            G_EXP=10,
            G_EXP_BYTE=50,
            G_MEMORY=3,
            G_TX_DATA_ZERO=4,
            G_TX_DATA_NON_ZERO=68,
            G_TX_DATA_STANDARD_TOKEN_COST=0,
            G_TX_DATA_FLOOR_TOKEN_COST=0,
            G_TRANSACTION=21_000,
            G_TRANSACTION_CREATE=32_000,
            G_LOG=375,
            G_LOG_DATA=8,
            G_LOG_TOPIC=375,
            G_KECCAK_256=30,
            G_KECCAK_256_WORD=6,
            G_COPY=3,
            G_BLOCKHASH=20,
            G_AUTHORIZATION=25_000,
        )

    @classmethod
    def memory_expansion_gas_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> MemoryExpansionGasCalculator:
        """
        Returns a callable that calculates the gas cost of memory expansion for the fork.
        """
        gas_costs = cls.gas_costs(block_number, timestamp)

        def fn(*, new_bytes: int, previous_bytes: int = 0) -> int:
            if new_bytes <= previous_bytes:
                return 0
            new_words = ceiling_division(new_bytes, 32)
            previous_words = ceiling_division(previous_bytes, 32)

            def c(w: int) -> int:
                return (gas_costs.G_MEMORY * w) + ((w * w) // 512)

            return c(new_words) - c(previous_words)

        return fn

    @classmethod
    def calldata_gas_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> CalldataGasCalculator:
        """
        Returns a callable that calculates the transaction gas cost for its calldata
        depending on its contents.
        """
        gas_costs = cls.gas_costs(block_number, timestamp)

        def fn(*, data: BytesConvertible, floor: bool = False) -> int:
            cost = 0
            for b in Bytes(data):
                if b == 0:
                    cost += gas_costs.G_TX_DATA_ZERO
                else:
                    cost += gas_costs.G_TX_DATA_NON_ZERO
            return cost

        return fn

    @classmethod
    def transaction_data_floor_cost_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> TransactionDataFloorCostCalculator:
        """
        At frontier, the transaction data floor cost is a constant zero.
        """

        def fn(*, data: BytesConvertible) -> int:
            return 0

        return fn

    @classmethod
    def transaction_intrinsic_cost_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> TransactionIntrinsicCostCalculator:
        """
        Returns a callable that calculates the intrinsic gas cost of a transaction for the fork.
        """
        gas_costs = cls.gas_costs(block_number, timestamp)
        calldata_gas_calculator = cls.calldata_gas_calculator(block_number, timestamp)

        def fn(
            *,
            calldata: BytesConvertible = b"",
            contract_creation: bool = False,
            access_list: List[AccessList] | None = None,
            authorization_list_or_count: Sized | int | None = None,
            return_cost_deducted_prior_execution: bool = False,
        ) -> int:
            assert access_list is None, f"Access list is not supported in {cls.name()}"
            assert (
                authorization_list_or_count is None
            ), f"Authorizations are not supported in {cls.name()}"
            intrinsic_cost: int = gas_costs.G_TRANSACTION

            if contract_creation:
                intrinsic_cost += gas_costs.G_INITCODE_WORD * ceiling_division(
                    len(Bytes(calldata)), 32
                )

            return intrinsic_cost + calldata_gas_calculator(data=calldata)

        return fn

    @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 target_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
        """
        Returns the target number of blobs per block for a given fork.
        """
        return 0

    @classmethod
    def max_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
        """
        Returns the max number of blobs per block for a given fork.
        """
        return 0

    @classmethod
    def header_requests_required(cls, block_number: int, timestamp: int) -> bool:
        """
        At genesis, header must not contain beacon chain requests.
        """
        return False

    @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 header_target_blobs_per_block_required(
        cls,
        block_number: int = 0,
        timestamp: int = 0,
    ) -> bool:
        """
        At genesis, header must not contain target blobs per block.
        """
        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_new_payload_requests(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        At genesis, payloads do not have requests.
        """
        return False

    @classmethod
    def engine_new_payload_target_blobs_per_block(
        cls,
        block_number: int = 0,
        timestamp: int = 0,
    ) -> bool:
        """
        At genesis, payloads do not have target blobs per block.
        """
        return False

    @classmethod
    def engine_payload_attribute_target_blobs_per_block(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> bool:
        """
        At genesis, payload attributes do not include the target blobs per block.
        """
        return False

    @classmethod
    def engine_payload_attribute_max_blobs_per_block(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> bool:
        """
        At genesis, payload attributes do not include the max blobs per block.
        """
        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 engine_get_payload_version(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> Optional[int]:
        """
        At genesis, payloads cannot be retrieved 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 contract_creating_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[Address]:
        """
        At Genesis, no pre-compiles are present
        """
        return []

    @classmethod
    def system_contracts(cls, block_number: int = 0, timestamp: int = 0) -> List[Address]:
        """
        At Genesis, no system-contracts are present
        """
        return []

    @classmethod
    def evm_code_types(cls, block_number: int = 0, timestamp: int = 0) -> List[EVMCodeType]:
        """
        At Genesis, only legacy EVM code is supported.
        """
        return [EVMCodeType.LEGACY]

    @classmethod
    def call_opcodes(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> List[Tuple[Opcodes, EVMCodeType]]:
        """
        Returns the list of call opcodes supported by the fork.
        """
        return [
            (Opcodes.CALL, EVMCodeType.LEGACY),
            (Opcodes.CALLCODE, EVMCodeType.LEGACY),
        ]

    @classmethod
    def valid_opcodes(
        cls,
    ) -> List[Opcodes]:
        """
        Returns the list of Opcodes that are valid to work on this fork.
        """
        return [
            Opcodes.STOP,
            Opcodes.ADD,
            Opcodes.MUL,
            Opcodes.SUB,
            Opcodes.DIV,
            Opcodes.SDIV,
            Opcodes.MOD,
            Opcodes.SMOD,
            Opcodes.ADDMOD,
            Opcodes.MULMOD,
            Opcodes.EXP,
            Opcodes.SIGNEXTEND,
            Opcodes.LT,
            Opcodes.GT,
            Opcodes.SLT,
            Opcodes.SGT,
            Opcodes.EQ,
            Opcodes.ISZERO,
            Opcodes.AND,
            Opcodes.OR,
            Opcodes.XOR,
            Opcodes.NOT,
            Opcodes.BYTE,
            Opcodes.SHA3,
            Opcodes.ADDRESS,
            Opcodes.BALANCE,
            Opcodes.ORIGIN,
            Opcodes.CALLER,
            Opcodes.CALLVALUE,
            Opcodes.CALLDATALOAD,
            Opcodes.CALLDATASIZE,
            Opcodes.CALLDATACOPY,
            Opcodes.CODESIZE,
            Opcodes.CODECOPY,
            Opcodes.GASPRICE,
            Opcodes.EXTCODESIZE,
            Opcodes.EXTCODECOPY,
            Opcodes.BLOCKHASH,
            Opcodes.COINBASE,
            Opcodes.TIMESTAMP,
            Opcodes.NUMBER,
            Opcodes.PREVRANDAO,
            Opcodes.GASLIMIT,
            Opcodes.POP,
            Opcodes.MLOAD,
            Opcodes.MSTORE,
            Opcodes.MSTORE8,
            Opcodes.SLOAD,
            Opcodes.SSTORE,
            Opcodes.PC,
            Opcodes.MSIZE,
            Opcodes.GAS,
            Opcodes.JUMP,
            Opcodes.JUMPI,
            Opcodes.JUMPDEST,
            Opcodes.PUSH1,
            Opcodes.PUSH2,
            Opcodes.PUSH3,
            Opcodes.PUSH4,
            Opcodes.PUSH5,
            Opcodes.PUSH6,
            Opcodes.PUSH7,
            Opcodes.PUSH8,
            Opcodes.PUSH9,
            Opcodes.PUSH10,
            Opcodes.PUSH11,
            Opcodes.PUSH12,
            Opcodes.PUSH13,
            Opcodes.PUSH14,
            Opcodes.PUSH15,
            Opcodes.PUSH16,
            Opcodes.PUSH17,
            Opcodes.PUSH18,
            Opcodes.PUSH19,
            Opcodes.PUSH20,
            Opcodes.PUSH21,
            Opcodes.PUSH22,
            Opcodes.PUSH23,
            Opcodes.PUSH24,
            Opcodes.PUSH25,
            Opcodes.PUSH26,
            Opcodes.PUSH27,
            Opcodes.PUSH28,
            Opcodes.PUSH29,
            Opcodes.PUSH30,
            Opcodes.PUSH31,
            Opcodes.PUSH32,
            Opcodes.DUP1,
            Opcodes.DUP2,
            Opcodes.DUP3,
            Opcodes.DUP4,
            Opcodes.DUP5,
            Opcodes.DUP6,
            Opcodes.DUP7,
            Opcodes.DUP8,
            Opcodes.DUP9,
            Opcodes.DUP10,
            Opcodes.DUP11,
            Opcodes.DUP12,
            Opcodes.DUP13,
            Opcodes.DUP14,
            Opcodes.DUP15,
            Opcodes.DUP16,
            Opcodes.SWAP1,
            Opcodes.SWAP2,
            Opcodes.SWAP3,
            Opcodes.SWAP4,
            Opcodes.SWAP5,
            Opcodes.SWAP6,
            Opcodes.SWAP7,
            Opcodes.SWAP8,
            Opcodes.SWAP9,
            Opcodes.SWAP10,
            Opcodes.SWAP11,
            Opcodes.SWAP12,
            Opcodes.SWAP13,
            Opcodes.SWAP14,
            Opcodes.SWAP15,
            Opcodes.SWAP16,
            Opcodes.LOG0,
            Opcodes.LOG1,
            Opcodes.LOG2,
            Opcodes.LOG3,
            Opcodes.LOG4,
            Opcodes.CREATE,
            Opcodes.CALL,
            Opcodes.CALLCODE,
            Opcodes.RETURN,
            Opcodes.SELFDESTRUCT,
        ]

    @classmethod
    def create_opcodes(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> List[Tuple[Opcodes, EVMCodeType]]:
        """
        At Genesis, only `CREATE` opcode is supported.
        """
        return [
            (Opcodes.CREATE, EVMCodeType.LEGACY),
        ]

    @classmethod
    def max_request_type(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """
        At genesis, no request type is supported, signaled by -1
        """
        return -1

    @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

gas_costs(block_number=0, timestamp=0) classmethod

Returns a dataclass with the defined gas costs constants for genesis.

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

@classmethod
def gas_costs(cls, block_number: int = 0, timestamp: int = 0) -> GasCosts:
    """
    Returns a dataclass with the defined gas costs constants for genesis.
    """
    return GasCosts(
        G_JUMPDEST=1,
        G_BASE=2,
        G_VERY_LOW=3,
        G_LOW=5,
        G_MID=8,
        G_HIGH=10,
        G_WARM_ACCOUNT_ACCESS=100,
        G_COLD_ACCOUNT_ACCESS=2_600,
        G_ACCESS_LIST_ADDRESS=2_400,
        G_ACCESS_LIST_STORAGE=1_900,
        G_WARM_SLOAD=100,
        G_COLD_SLOAD=2_100,
        G_STORAGE_SET=20_000,
        G_STORAGE_RESET=2_900,
        R_STORAGE_CLEAR=4_800,
        G_SELF_DESTRUCT=5_000,
        G_CREATE=32_000,
        G_CODE_DEPOSIT_BYTE=200,
        G_INITCODE_WORD=2,
        G_CALL_VALUE=9_000,
        G_CALL_STIPEND=2_300,
        G_NEW_ACCOUNT=25_000,
        G_EXP=10,
        G_EXP_BYTE=50,
        G_MEMORY=3,
        G_TX_DATA_ZERO=4,
        G_TX_DATA_NON_ZERO=68,
        G_TX_DATA_STANDARD_TOKEN_COST=0,
        G_TX_DATA_FLOOR_TOKEN_COST=0,
        G_TRANSACTION=21_000,
        G_TRANSACTION_CREATE=32_000,
        G_LOG=375,
        G_LOG_DATA=8,
        G_LOG_TOPIC=375,
        G_KECCAK_256=30,
        G_KECCAK_256_WORD=6,
        G_COPY=3,
        G_BLOCKHASH=20,
        G_AUTHORIZATION=25_000,
    )

memory_expansion_gas_calculator(block_number=0, timestamp=0) classmethod

Returns a callable that calculates the gas cost of memory expansion for the fork.

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

@classmethod
def memory_expansion_gas_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> MemoryExpansionGasCalculator:
    """
    Returns a callable that calculates the gas cost of memory expansion for the fork.
    """
    gas_costs = cls.gas_costs(block_number, timestamp)

    def fn(*, new_bytes: int, previous_bytes: int = 0) -> int:
        if new_bytes <= previous_bytes:
            return 0
        new_words = ceiling_division(new_bytes, 32)
        previous_words = ceiling_division(previous_bytes, 32)

        def c(w: int) -> int:
            return (gas_costs.G_MEMORY * w) + ((w * w) // 512)

        return c(new_words) - c(previous_words)

    return fn

calldata_gas_calculator(block_number=0, timestamp=0) classmethod

Returns a callable that calculates the transaction gas cost for its calldata depending on its contents.

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

@classmethod
def calldata_gas_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> CalldataGasCalculator:
    """
    Returns a callable that calculates the transaction gas cost for its calldata
    depending on its contents.
    """
    gas_costs = cls.gas_costs(block_number, timestamp)

    def fn(*, data: BytesConvertible, floor: bool = False) -> int:
        cost = 0
        for b in Bytes(data):
            if b == 0:
                cost += gas_costs.G_TX_DATA_ZERO
            else:
                cost += gas_costs.G_TX_DATA_NON_ZERO
        return cost

    return fn

transaction_data_floor_cost_calculator(block_number=0, timestamp=0) classmethod

At frontier, the transaction data floor cost is a constant zero.

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

@classmethod
def transaction_data_floor_cost_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> TransactionDataFloorCostCalculator:
    """
    At frontier, the transaction data floor cost is a constant zero.
    """

    def fn(*, data: BytesConvertible) -> int:
        return 0

    return fn

transaction_intrinsic_cost_calculator(block_number=0, timestamp=0) classmethod

Returns a callable that calculates the intrinsic gas cost of a transaction for the fork.

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

@classmethod
def transaction_intrinsic_cost_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> TransactionIntrinsicCostCalculator:
    """
    Returns a callable that calculates the intrinsic gas cost of a transaction for the fork.
    """
    gas_costs = cls.gas_costs(block_number, timestamp)
    calldata_gas_calculator = cls.calldata_gas_calculator(block_number, timestamp)

    def fn(
        *,
        calldata: BytesConvertible = b"",
        contract_creation: bool = False,
        access_list: List[AccessList] | None = None,
        authorization_list_or_count: Sized | int | None = None,
        return_cost_deducted_prior_execution: bool = False,
    ) -> int:
        assert access_list is None, f"Access list is not supported in {cls.name()}"
        assert (
            authorization_list_or_count is None
        ), f"Authorizations are not supported in {cls.name()}"
        intrinsic_cost: int = gas_costs.G_TRANSACTION

        if contract_creation:
            intrinsic_cost += gas_costs.G_INITCODE_WORD * ceiling_division(
                len(Bytes(calldata)), 32
            )

        return intrinsic_cost + calldata_gas_calculator(data=calldata)

    return fn

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

target_blobs_per_block(block_number, timestamp) classmethod

Returns the target number of blobs per block for a given fork.

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

@classmethod
def target_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
    """
    Returns the target number of blobs per block for a given fork.
    """
    return 0

max_blobs_per_block(block_number, timestamp) classmethod

Returns the max number of blobs per block for a given fork.

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

@classmethod
def max_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
    """
    Returns the max number of blobs per block for a given fork.
    """
    return 0

header_requests_required(block_number, timestamp) classmethod

At genesis, header must not contain beacon chain requests.

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

@classmethod
def header_requests_required(cls, block_number: int, timestamp: int) -> bool:
    """
    At genesis, header must not contain beacon chain requests.
    """
    return False

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

header_target_blobs_per_block_required(block_number=0, timestamp=0) classmethod

At genesis, header must not contain target blobs per block.

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

@classmethod
def header_target_blobs_per_block_required(
    cls,
    block_number: int = 0,
    timestamp: int = 0,
) -> bool:
    """
    At genesis, header must not contain target blobs per block.
    """
    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_new_payload_requests(block_number=0, timestamp=0) classmethod

At genesis, payloads do not have requests.

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

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

engine_new_payload_target_blobs_per_block(block_number=0, timestamp=0) classmethod

At genesis, payloads do not have target blobs per block.

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

@classmethod
def engine_new_payload_target_blobs_per_block(
    cls,
    block_number: int = 0,
    timestamp: int = 0,
) -> bool:
    """
    At genesis, payloads do not have target blobs per block.
    """
    return False

engine_payload_attribute_target_blobs_per_block(block_number=0, timestamp=0) classmethod

At genesis, payload attributes do not include the target blobs per block.

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

@classmethod
def engine_payload_attribute_target_blobs_per_block(
    cls, block_number: int = 0, timestamp: int = 0
) -> bool:
    """
    At genesis, payload attributes do not include the target blobs per block.
    """
    return False

engine_payload_attribute_max_blobs_per_block(block_number=0, timestamp=0) classmethod

At genesis, payload attributes do not include the max blobs per block.

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

@classmethod
def engine_payload_attribute_max_blobs_per_block(
    cls, block_number: int = 0, timestamp: int = 0
) -> bool:
    """
    At genesis, payload attributes do not include the max blobs per block.
    """
    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)

engine_get_payload_version(block_number=0, timestamp=0) classmethod

At genesis, payloads cannot be retrieved through the engine API.

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

@classmethod
def engine_get_payload_version(
    cls, block_number: int = 0, timestamp: int = 0
) -> Optional[int]:
    """
    At genesis, payloads cannot be retrieved 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]

contract_creating_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 contract_creating_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 present

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

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

system_contracts(block_number=0, timestamp=0) classmethod

At Genesis, no system-contracts are present

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

@classmethod
def system_contracts(cls, block_number: int = 0, timestamp: int = 0) -> List[Address]:
    """
    At Genesis, no system-contracts are present
    """
    return []

evm_code_types(block_number=0, timestamp=0) classmethod

At Genesis, only legacy EVM code is supported.

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

@classmethod
def evm_code_types(cls, block_number: int = 0, timestamp: int = 0) -> List[EVMCodeType]:
    """
    At Genesis, only legacy EVM code is supported.
    """
    return [EVMCodeType.LEGACY]

call_opcodes(block_number=0, timestamp=0) classmethod

Returns the list of call opcodes supported by the fork.

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

@classmethod
def call_opcodes(
    cls, block_number: int = 0, timestamp: int = 0
) -> List[Tuple[Opcodes, EVMCodeType]]:
    """
    Returns the list of call opcodes supported by the fork.
    """
    return [
        (Opcodes.CALL, EVMCodeType.LEGACY),
        (Opcodes.CALLCODE, EVMCodeType.LEGACY),
    ]

valid_opcodes() classmethod

Returns the list of Opcodes that are valid to work on this fork.

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

@classmethod
def valid_opcodes(
    cls,
) -> List[Opcodes]:
    """
    Returns the list of Opcodes that are valid to work on this fork.
    """
    return [
        Opcodes.STOP,
        Opcodes.ADD,
        Opcodes.MUL,
        Opcodes.SUB,
        Opcodes.DIV,
        Opcodes.SDIV,
        Opcodes.MOD,
        Opcodes.SMOD,
        Opcodes.ADDMOD,
        Opcodes.MULMOD,
        Opcodes.EXP,
        Opcodes.SIGNEXTEND,
        Opcodes.LT,
        Opcodes.GT,
        Opcodes.SLT,
        Opcodes.SGT,
        Opcodes.EQ,
        Opcodes.ISZERO,
        Opcodes.AND,
        Opcodes.OR,
        Opcodes.XOR,
        Opcodes.NOT,
        Opcodes.BYTE,
        Opcodes.SHA3,
        Opcodes.ADDRESS,
        Opcodes.BALANCE,
        Opcodes.ORIGIN,
        Opcodes.CALLER,
        Opcodes.CALLVALUE,
        Opcodes.CALLDATALOAD,
        Opcodes.CALLDATASIZE,
        Opcodes.CALLDATACOPY,
        Opcodes.CODESIZE,
        Opcodes.CODECOPY,
        Opcodes.GASPRICE,
        Opcodes.EXTCODESIZE,
        Opcodes.EXTCODECOPY,
        Opcodes.BLOCKHASH,
        Opcodes.COINBASE,
        Opcodes.TIMESTAMP,
        Opcodes.NUMBER,
        Opcodes.PREVRANDAO,
        Opcodes.GASLIMIT,
        Opcodes.POP,
        Opcodes.MLOAD,
        Opcodes.MSTORE,
        Opcodes.MSTORE8,
        Opcodes.SLOAD,
        Opcodes.SSTORE,
        Opcodes.PC,
        Opcodes.MSIZE,
        Opcodes.GAS,
        Opcodes.JUMP,
        Opcodes.JUMPI,
        Opcodes.JUMPDEST,
        Opcodes.PUSH1,
        Opcodes.PUSH2,
        Opcodes.PUSH3,
        Opcodes.PUSH4,
        Opcodes.PUSH5,
        Opcodes.PUSH6,
        Opcodes.PUSH7,
        Opcodes.PUSH8,
        Opcodes.PUSH9,
        Opcodes.PUSH10,
        Opcodes.PUSH11,
        Opcodes.PUSH12,
        Opcodes.PUSH13,
        Opcodes.PUSH14,
        Opcodes.PUSH15,
        Opcodes.PUSH16,
        Opcodes.PUSH17,
        Opcodes.PUSH18,
        Opcodes.PUSH19,
        Opcodes.PUSH20,
        Opcodes.PUSH21,
        Opcodes.PUSH22,
        Opcodes.PUSH23,
        Opcodes.PUSH24,
        Opcodes.PUSH25,
        Opcodes.PUSH26,
        Opcodes.PUSH27,
        Opcodes.PUSH28,
        Opcodes.PUSH29,
        Opcodes.PUSH30,
        Opcodes.PUSH31,
        Opcodes.PUSH32,
        Opcodes.DUP1,
        Opcodes.DUP2,
        Opcodes.DUP3,
        Opcodes.DUP4,
        Opcodes.DUP5,
        Opcodes.DUP6,
        Opcodes.DUP7,
        Opcodes.DUP8,
        Opcodes.DUP9,
        Opcodes.DUP10,
        Opcodes.DUP11,
        Opcodes.DUP12,
        Opcodes.DUP13,
        Opcodes.DUP14,
        Opcodes.DUP15,
        Opcodes.DUP16,
        Opcodes.SWAP1,
        Opcodes.SWAP2,
        Opcodes.SWAP3,
        Opcodes.SWAP4,
        Opcodes.SWAP5,
        Opcodes.SWAP6,
        Opcodes.SWAP7,
        Opcodes.SWAP8,
        Opcodes.SWAP9,
        Opcodes.SWAP10,
        Opcodes.SWAP11,
        Opcodes.SWAP12,
        Opcodes.SWAP13,
        Opcodes.SWAP14,
        Opcodes.SWAP15,
        Opcodes.SWAP16,
        Opcodes.LOG0,
        Opcodes.LOG1,
        Opcodes.LOG2,
        Opcodes.LOG3,
        Opcodes.LOG4,
        Opcodes.CREATE,
        Opcodes.CALL,
        Opcodes.CALLCODE,
        Opcodes.RETURN,
        Opcodes.SELFDESTRUCT,
    ]

create_opcodes(block_number=0, timestamp=0) classmethod

At Genesis, only CREATE opcode is supported.

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

@classmethod
def create_opcodes(
    cls, block_number: int = 0, timestamp: int = 0
) -> List[Tuple[Opcodes, EVMCodeType]]:
    """
    At Genesis, only `CREATE` opcode is supported.
    """
    return [
        (Opcodes.CREATE, EVMCodeType.LEGACY),
    ]

max_request_type(block_number=0, timestamp=0) classmethod

At genesis, no request type is supported, signaled by -1

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

@classmethod
def max_request_type(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """
    At genesis, no request type is supported, signaled by -1
    """
    return -1

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[Address]:
        """
        At Homestead, EC-recover, SHA256, RIPEMD160, and Identity pre-compiles are introduced
        """
        return list(Address(i) for i in range(1, 5)) + super(Homestead, cls).precompiles(
            block_number, timestamp
        )

    @classmethod
    def call_opcodes(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> List[Tuple[Opcodes, EVMCodeType]]:
        """
        At Homestead, DELEGATECALL opcode was introduced.
        """
        return [(Opcodes.DELEGATECALL, EVMCodeType.LEGACY)] + super(Homestead, cls).call_opcodes(
            block_number, timestamp
        )

    @classmethod
    def valid_opcodes(
        cls,
    ) -> List[Opcodes]:
        """
        Returns the list of Opcodes that are valid to work on this fork.
        """
        return [Opcodes.DELEGATECALL] + super(Homestead, cls).valid_opcodes()

    @classmethod
    def transaction_intrinsic_cost_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> TransactionIntrinsicCostCalculator:
        """
        At Homestead, the transaction intrinsic cost needs to take contract creation into account.
        """
        super_fn = super(Homestead, cls).transaction_intrinsic_cost_calculator(
            block_number, timestamp
        )
        gas_costs = cls.gas_costs(block_number, timestamp)

        def fn(
            *,
            calldata: BytesConvertible = b"",
            contract_creation: bool = False,
            access_list: List[AccessList] | None = None,
            authorization_list_or_count: Sized | int | None = None,
            return_cost_deducted_prior_execution: bool = False,
        ) -> int:
            intrinsic_cost: int = super_fn(
                calldata=calldata,
                contract_creation=contract_creation,
                access_list=access_list,
                authorization_list_or_count=authorization_list_or_count,
            )
            if contract_creation:
                intrinsic_cost += gas_costs.G_TRANSACTION_CREATE
            return intrinsic_cost

        return fn

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[Address]:
    """
    At Homestead, EC-recover, SHA256, RIPEMD160, and Identity pre-compiles are introduced
    """
    return list(Address(i) for i in range(1, 5)) + super(Homestead, cls).precompiles(
        block_number, timestamp
    )

call_opcodes(block_number=0, timestamp=0) classmethod

At Homestead, DELEGATECALL opcode was introduced.

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

@classmethod
def call_opcodes(
    cls, block_number: int = 0, timestamp: int = 0
) -> List[Tuple[Opcodes, EVMCodeType]]:
    """
    At Homestead, DELEGATECALL opcode was introduced.
    """
    return [(Opcodes.DELEGATECALL, EVMCodeType.LEGACY)] + super(Homestead, cls).call_opcodes(
        block_number, timestamp
    )

valid_opcodes() classmethod

Returns the list of Opcodes that are valid to work on this fork.

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

@classmethod
def valid_opcodes(
    cls,
) -> List[Opcodes]:
    """
    Returns the list of Opcodes that are valid to work on this fork.
    """
    return [Opcodes.DELEGATECALL] + super(Homestead, cls).valid_opcodes()

transaction_intrinsic_cost_calculator(block_number=0, timestamp=0) classmethod

At Homestead, the transaction intrinsic cost needs to take contract creation into account.

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

@classmethod
def transaction_intrinsic_cost_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> TransactionIntrinsicCostCalculator:
    """
    At Homestead, the transaction intrinsic cost needs to take contract creation into account.
    """
    super_fn = super(Homestead, cls).transaction_intrinsic_cost_calculator(
        block_number, timestamp
    )
    gas_costs = cls.gas_costs(block_number, timestamp)

    def fn(
        *,
        calldata: BytesConvertible = b"",
        contract_creation: bool = False,
        access_list: List[AccessList] | None = None,
        authorization_list_or_count: Sized | int | None = None,
        return_cost_deducted_prior_execution: bool = False,
    ) -> int:
        intrinsic_cost: int = super_fn(
            calldata=calldata,
            contract_creation=contract_creation,
            access_list=access_list,
            authorization_list_or_count=authorization_list_or_count,
        )
        if contract_creation:
            intrinsic_cost += gas_costs.G_TRANSACTION_CREATE
        return intrinsic_cost

    return fn

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[Address]:
        """
        At Istanbul, pre-compile for blake2 compression is introduced
        """
        return [Address(9)] + super(Istanbul, cls).precompiles(block_number, timestamp)

    @classmethod
    def valid_opcodes(
        cls,
    ) -> List[Opcodes]:
        """
        Returns the list of Opcodes that are valid to work on this fork.
        """
        return [Opcodes.CHAINID, Opcodes.SELFBALANCE] + super(Istanbul, cls).valid_opcodes()

    @classmethod
    def gas_costs(cls, block_number: int = 0, timestamp: int = 0) -> GasCosts:
        """
        On Istanbul, the non-zero transaction data byte cost is reduced to 16 due to EIP-2028.
        """
        return replace(
            super(Istanbul, cls).gas_costs(block_number, timestamp),
            G_TX_DATA_NON_ZERO=16,  # https://eips.ethereum.org/EIPS/eip-2028
        )

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[Address]:
    """
    At Istanbul, pre-compile for blake2 compression is introduced
    """
    return [Address(9)] + super(Istanbul, cls).precompiles(block_number, timestamp)

valid_opcodes() classmethod

Returns the list of Opcodes that are valid to work on this fork.

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

@classmethod
def valid_opcodes(
    cls,
) -> List[Opcodes]:
    """
    Returns the list of Opcodes that are valid to work on this fork.
    """
    return [Opcodes.CHAINID, Opcodes.SELFBALANCE] + super(Istanbul, cls).valid_opcodes()

gas_costs(block_number=0, timestamp=0) classmethod

On Istanbul, the non-zero transaction data byte cost is reduced to 16 due to EIP-2028.

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

@classmethod
def gas_costs(cls, block_number: int = 0, timestamp: int = 0) -> GasCosts:
    """
    On Istanbul, the non-zero transaction data byte cost is reduced to 16 due to EIP-2028.
    """
    return replace(
        super(Istanbul, cls).gas_costs(block_number, timestamp),
        G_TX_DATA_NON_ZERO=16,  # https://eips.ethereum.org/EIPS/eip-2028
    )

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)

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

    @classmethod
    def valid_opcodes(
        cls,
    ) -> List[Opcodes]:
        """
        Returns the list of Opcodes that are valid to work on this fork.
        """
        return [Opcodes.BASEFEE] + super(London, cls).valid_opcodes()

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)

contract_creating_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 contract_creating_tx_types(cls, block_number: int = 0, timestamp: int = 0) -> List[int]:
    """
    At London, dynamic fee transactions are introduced
    """
    return [2] + super(London, cls).contract_creating_tx_types(block_number, timestamp)

valid_opcodes() classmethod

Returns the list of Opcodes that are valid to work on this fork.

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

@classmethod
def valid_opcodes(
    cls,
) -> List[Opcodes]:
    """
    Returns the list of Opcodes that are valid to work on this fork.
    """
    return [Opcodes.BASEFEE] + super(London, cls).valid_opcodes()

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

Osaka

Bases: Prague

Osaka fork

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

class Osaka(Prague, solc_name="cancun"):
    """
    Osaka fork
    """

    @classmethod
    def evm_code_types(cls, block_number: int = 0, timestamp: int = 0) -> List[EVMCodeType]:
        """
        EOF V1 is supported starting from Osaka.
        """
        return super(Osaka, cls).evm_code_types(
            block_number,
            timestamp,
        ) + [EVMCodeType.EOF_V1]

    @classmethod
    def call_opcodes(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> List[Tuple[Opcodes, EVMCodeType]]:
        """
        EOF V1 introduces EXTCALL, EXTSTATICCALL, EXTDELEGATECALL.
        """
        return [
            (Opcodes.EXTCALL, EVMCodeType.EOF_V1),
            (Opcodes.EXTSTATICCALL, EVMCodeType.EOF_V1),
            (Opcodes.EXTDELEGATECALL, EVMCodeType.EOF_V1),
        ] + super(Osaka, cls).call_opcodes(block_number, timestamp)

    @classmethod
    def is_deployed(cls) -> bool:
        """
        Flags that the fork 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("1.0.0")  # set a high version; currently unknown

evm_code_types(block_number=0, timestamp=0) classmethod

EOF V1 is supported starting from Osaka.

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

@classmethod
def evm_code_types(cls, block_number: int = 0, timestamp: int = 0) -> List[EVMCodeType]:
    """
    EOF V1 is supported starting from Osaka.
    """
    return super(Osaka, cls).evm_code_types(
        block_number,
        timestamp,
    ) + [EVMCodeType.EOF_V1]

call_opcodes(block_number=0, timestamp=0) classmethod

EOF V1 introduces EXTCALL, EXTSTATICCALL, EXTDELEGATECALL.

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

@classmethod
def call_opcodes(
    cls, block_number: int = 0, timestamp: int = 0
) -> List[Tuple[Opcodes, EVMCodeType]]:
    """
    EOF V1 introduces EXTCALL, EXTSTATICCALL, EXTDELEGATECALL.
    """
    return [
        (Opcodes.EXTCALL, EVMCodeType.EOF_V1),
        (Opcodes.EXTSTATICCALL, EVMCodeType.EOF_V1),
        (Opcodes.EXTDELEGATECALL, EVMCodeType.EOF_V1),
    ] + super(Osaka, cls).call_opcodes(block_number, timestamp)

is_deployed() classmethod

Flags that the fork 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) -> bool:
    """
    Flags that the fork 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("1.0.0")  # set a high version; currently unknown

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="Paris",
):
    """
    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

Prague

Bases: Cancun

Prague fork

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

class Prague(Cancun):
    """
    Prague fork
    """

    @classmethod
    def is_deployed(cls) -> bool:
        """
        Flags that the fork 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("1.0.0")  # set a high version; currently unknown

    @classmethod
    def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[Address]:
        """
        At Prague, pre-compile for BLS operations are added:

        G1ADD = 0x0B
        G1MSM = 0x0C
        G2ADD = 0x0D
        G2MSM = 0x0E
        PAIRING = 0x0F
        MAP_FP_TO_G1 = 0x10
        MAP_FP2_TO_G2 = 0x11
        """
        return list(Address(i) for i in range(0xB, 0x11 + 1)) + super(Prague, cls).precompiles(
            block_number, timestamp
        )

    @classmethod
    def gas_costs(cls, block_number: int = 0, timestamp: int = 0) -> GasCosts:
        """
        On Prague, the standard token cost and the floor token costs are introduced due to EIP-7623
        """
        return replace(
            super(Prague, cls).gas_costs(block_number, timestamp),
            G_TX_DATA_STANDARD_TOKEN_COST=4,  # https://eips.ethereum.org/EIPS/eip-7623
            G_TX_DATA_FLOOR_TOKEN_COST=10,
        )

    @classmethod
    def system_contracts(cls, block_number: int = 0, timestamp: int = 0) -> List[Address]:
        """
        Prague introduces the system contracts for EIP-6110, EIP-7002, EIP-7251 and EIP-2935
        """
        return [
            Address(0x00000000219AB540356CBB839CBE05303D7705FA),
            Address(0x09FC772D0857550724B07B850A4323F39112AAAA),
            Address(0x01ABEA29659E5E97C95107F20BB753CD3E09BBBB),
            Address(0x0AAE40965E6800CD9B1F4B05FF21581047E3F91E),
        ] + super(Prague, cls).system_contracts(block_number, timestamp)

    @classmethod
    def max_request_type(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """
        At Prague, three request types are introduced, hence the max request type is 2
        """
        return 2

    @classmethod
    def calldata_gas_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> CalldataGasCalculator:
        """
        Returns a callable that calculates the transaction gas cost for its calldata
        depending on its contents.
        """
        gas_costs = cls.gas_costs(block_number, timestamp)

        def fn(*, data: BytesConvertible, floor: bool = False) -> int:
            tokens = 0
            for b in Bytes(data):
                if b == 0:
                    tokens += 1
                else:
                    tokens += 4
            if floor:
                return tokens * gas_costs.G_TX_DATA_FLOOR_TOKEN_COST
            return tokens * gas_costs.G_TX_DATA_STANDARD_TOKEN_COST

        return fn

    @classmethod
    def transaction_data_floor_cost_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> TransactionDataFloorCostCalculator:
        """
        Starting in Prague, due to EIP-7623, the transaction data floor cost is introduced.
        """
        calldata_gas_calculator = cls.calldata_gas_calculator(block_number, timestamp)
        gas_costs = cls.gas_costs(block_number, timestamp)

        def fn(*, data: BytesConvertible) -> int:
            return calldata_gas_calculator(data=data, floor=True) + gas_costs.G_TRANSACTION

        return fn

    @classmethod
    def transaction_intrinsic_cost_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> TransactionIntrinsicCostCalculator:
        """
        At Prague, the transaction intrinsic cost needs to take the authorizations into account
        """
        super_fn = super(Prague, cls).transaction_intrinsic_cost_calculator(
            block_number, timestamp
        )
        gas_costs = cls.gas_costs(block_number, timestamp)
        transaction_data_floor_cost_calculator = cls.transaction_data_floor_cost_calculator(
            block_number, timestamp
        )

        def fn(
            *,
            calldata: BytesConvertible = b"",
            contract_creation: bool = False,
            access_list: List[AccessList] | None = None,
            authorization_list_or_count: Sized | int | None = None,
            return_cost_deducted_prior_execution: bool = False,
        ) -> int:
            intrinsic_cost: int = super_fn(
                calldata=calldata,
                contract_creation=contract_creation,
                access_list=access_list,
                return_cost_deducted_prior_execution=False,
            )
            if authorization_list_or_count is not None:
                if isinstance(authorization_list_or_count, Sized):
                    authorization_list_or_count = len(authorization_list_or_count)
                intrinsic_cost += authorization_list_or_count * gas_costs.G_AUTHORIZATION

            if return_cost_deducted_prior_execution:
                return intrinsic_cost

            transaction_floor_data_cost = transaction_data_floor_cost_calculator(data=calldata)
            return max(intrinsic_cost, transaction_floor_data_cost)

        return fn

    @classmethod
    def pre_allocation_blockchain(cls) -> Mapping:
        """
        Prague requires pre-allocation of the beacon chain deposit contract for EIP-6110,
        the exits contract for EIP-7002, and the history storage contract for EIP-2935.
        """
        new_allocation = {}

        # Add the beacon chain deposit contract
        DEPOSIT_CONTRACT_TREE_DEPTH = 32
        storage = {}
        next_hash = sha256(b"\x00" * 64).digest()
        for i in range(DEPOSIT_CONTRACT_TREE_DEPTH + 2, DEPOSIT_CONTRACT_TREE_DEPTH * 2 + 1):
            storage[i] = next_hash
            next_hash = sha256(next_hash + next_hash).digest()

        with open(CURRENT_FOLDER / "contracts" / "deposit_contract.bin", mode="rb") as f:
            new_allocation.update(
                {
                    0x00000000219AB540356CBB839CBE05303D7705FA: {
                        "nonce": 1,
                        "code": f.read(),
                        "storage": storage,
                    }
                }
            )

        # Add the withdrawal request contract
        with open(CURRENT_FOLDER / "contracts" / "withdrawal_request.bin", mode="rb") as f:
            new_allocation.update(
                {
                    0x09FC772D0857550724B07B850A4323F39112AAAA: {
                        "nonce": 1,
                        "code": f.read(),
                    },
                }
            )

        # Add the consolidation request contract
        with open(CURRENT_FOLDER / "contracts" / "consolidation_request.bin", mode="rb") as f:
            new_allocation.update(
                {
                    0x01ABEA29659E5E97C95107F20BB753CD3E09BBBB: {
                        "nonce": 1,
                        "code": f.read(),
                    },
                }
            )

        # Add the history storage contract
        with open(CURRENT_FOLDER / "contracts" / "history_contract.bin", mode="rb") as f:
            new_allocation.update(
                {
                    0x0AAE40965E6800CD9B1F4B05FF21581047E3F91E: {
                        "nonce": 1,
                        "code": f.read(),
                    }
                }
            )

        return new_allocation | super(Prague, cls).pre_allocation_blockchain()  # type: ignore

    @classmethod
    def header_requests_required(cls, block_number: int, timestamp: int) -> bool:
        """
        Prague requires that the execution layer header contains the beacon
        chain requests hash.
        """
        return True

    @classmethod
    def header_target_blobs_per_block_required(
        cls,
        block_number: int = 0,
        timestamp: int = 0,
    ) -> bool:
        """
        Prague requires that the execution layer header contains the beacon
        chain target blobs per block.
        """
        return True

    @classmethod
    def engine_new_payload_requests(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """
        Starting at Prague, new payloads include the requests hash as a parameter.
        """
        return True

    @classmethod
    def engine_new_payload_target_blobs_per_block(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> bool:
        """
        Starting at Prague, new payloads include the target blobs per block as a parameter.
        """
        return True

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

    @classmethod
    def engine_payload_attribute_target_blobs_per_block(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> bool:
        """
        Starting at Prague, payload attributes include the target blobs per block.
        """
        return True

    @classmethod
    def engine_payload_attribute_max_blobs_per_block(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> bool:
        """
        Starting at Prague, payload attributes include the max blobs per block.
        """
        return True

is_deployed() classmethod

Flags that the fork 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) -> bool:
    """
    Flags that the fork 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("1.0.0")  # set a high version; currently unknown

precompiles(block_number=0, timestamp=0) classmethod

At Prague, pre-compile for BLS operations are added:

G1ADD = 0x0B G1MSM = 0x0C G2ADD = 0x0D G2MSM = 0x0E PAIRING = 0x0F MAP_FP_TO_G1 = 0x10 MAP_FP2_TO_G2 = 0x11

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

@classmethod
def precompiles(cls, block_number: int = 0, timestamp: int = 0) -> List[Address]:
    """
    At Prague, pre-compile for BLS operations are added:

    G1ADD = 0x0B
    G1MSM = 0x0C
    G2ADD = 0x0D
    G2MSM = 0x0E
    PAIRING = 0x0F
    MAP_FP_TO_G1 = 0x10
    MAP_FP2_TO_G2 = 0x11
    """
    return list(Address(i) for i in range(0xB, 0x11 + 1)) + super(Prague, cls).precompiles(
        block_number, timestamp
    )

gas_costs(block_number=0, timestamp=0) classmethod

On Prague, the standard token cost and the floor token costs are introduced due to EIP-7623

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

@classmethod
def gas_costs(cls, block_number: int = 0, timestamp: int = 0) -> GasCosts:
    """
    On Prague, the standard token cost and the floor token costs are introduced due to EIP-7623
    """
    return replace(
        super(Prague, cls).gas_costs(block_number, timestamp),
        G_TX_DATA_STANDARD_TOKEN_COST=4,  # https://eips.ethereum.org/EIPS/eip-7623
        G_TX_DATA_FLOOR_TOKEN_COST=10,
    )

system_contracts(block_number=0, timestamp=0) classmethod

Prague introduces the system contracts for EIP-6110, EIP-7002, EIP-7251 and EIP-2935

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

@classmethod
def system_contracts(cls, block_number: int = 0, timestamp: int = 0) -> List[Address]:
    """
    Prague introduces the system contracts for EIP-6110, EIP-7002, EIP-7251 and EIP-2935
    """
    return [
        Address(0x00000000219AB540356CBB839CBE05303D7705FA),
        Address(0x09FC772D0857550724B07B850A4323F39112AAAA),
        Address(0x01ABEA29659E5E97C95107F20BB753CD3E09BBBB),
        Address(0x0AAE40965E6800CD9B1F4B05FF21581047E3F91E),
    ] + super(Prague, cls).system_contracts(block_number, timestamp)

max_request_type(block_number=0, timestamp=0) classmethod

At Prague, three request types are introduced, hence the max request type is 2

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

@classmethod
def max_request_type(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """
    At Prague, three request types are introduced, hence the max request type is 2
    """
    return 2

calldata_gas_calculator(block_number=0, timestamp=0) classmethod

Returns a callable that calculates the transaction gas cost for its calldata depending on its contents.

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

@classmethod
def calldata_gas_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> CalldataGasCalculator:
    """
    Returns a callable that calculates the transaction gas cost for its calldata
    depending on its contents.
    """
    gas_costs = cls.gas_costs(block_number, timestamp)

    def fn(*, data: BytesConvertible, floor: bool = False) -> int:
        tokens = 0
        for b in Bytes(data):
            if b == 0:
                tokens += 1
            else:
                tokens += 4
        if floor:
            return tokens * gas_costs.G_TX_DATA_FLOOR_TOKEN_COST
        return tokens * gas_costs.G_TX_DATA_STANDARD_TOKEN_COST

    return fn

transaction_data_floor_cost_calculator(block_number=0, timestamp=0) classmethod

Starting in Prague, due to EIP-7623, the transaction data floor cost is introduced.

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

@classmethod
def transaction_data_floor_cost_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> TransactionDataFloorCostCalculator:
    """
    Starting in Prague, due to EIP-7623, the transaction data floor cost is introduced.
    """
    calldata_gas_calculator = cls.calldata_gas_calculator(block_number, timestamp)
    gas_costs = cls.gas_costs(block_number, timestamp)

    def fn(*, data: BytesConvertible) -> int:
        return calldata_gas_calculator(data=data, floor=True) + gas_costs.G_TRANSACTION

    return fn

transaction_intrinsic_cost_calculator(block_number=0, timestamp=0) classmethod

At Prague, the transaction intrinsic cost needs to take the authorizations into account

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

@classmethod
def transaction_intrinsic_cost_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> TransactionIntrinsicCostCalculator:
    """
    At Prague, the transaction intrinsic cost needs to take the authorizations into account
    """
    super_fn = super(Prague, cls).transaction_intrinsic_cost_calculator(
        block_number, timestamp
    )
    gas_costs = cls.gas_costs(block_number, timestamp)
    transaction_data_floor_cost_calculator = cls.transaction_data_floor_cost_calculator(
        block_number, timestamp
    )

    def fn(
        *,
        calldata: BytesConvertible = b"",
        contract_creation: bool = False,
        access_list: List[AccessList] | None = None,
        authorization_list_or_count: Sized | int | None = None,
        return_cost_deducted_prior_execution: bool = False,
    ) -> int:
        intrinsic_cost: int = super_fn(
            calldata=calldata,
            contract_creation=contract_creation,
            access_list=access_list,
            return_cost_deducted_prior_execution=False,
        )
        if authorization_list_or_count is not None:
            if isinstance(authorization_list_or_count, Sized):
                authorization_list_or_count = len(authorization_list_or_count)
            intrinsic_cost += authorization_list_or_count * gas_costs.G_AUTHORIZATION

        if return_cost_deducted_prior_execution:
            return intrinsic_cost

        transaction_floor_data_cost = transaction_data_floor_cost_calculator(data=calldata)
        return max(intrinsic_cost, transaction_floor_data_cost)

    return fn

pre_allocation_blockchain() classmethod

Prague requires pre-allocation of the beacon chain deposit contract for EIP-6110, the exits contract for EIP-7002, and the history storage contract for EIP-2935.

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

@classmethod
def pre_allocation_blockchain(cls) -> Mapping:
    """
    Prague requires pre-allocation of the beacon chain deposit contract for EIP-6110,
    the exits contract for EIP-7002, and the history storage contract for EIP-2935.
    """
    new_allocation = {}

    # Add the beacon chain deposit contract
    DEPOSIT_CONTRACT_TREE_DEPTH = 32
    storage = {}
    next_hash = sha256(b"\x00" * 64).digest()
    for i in range(DEPOSIT_CONTRACT_TREE_DEPTH + 2, DEPOSIT_CONTRACT_TREE_DEPTH * 2 + 1):
        storage[i] = next_hash
        next_hash = sha256(next_hash + next_hash).digest()

    with open(CURRENT_FOLDER / "contracts" / "deposit_contract.bin", mode="rb") as f:
        new_allocation.update(
            {
                0x00000000219AB540356CBB839CBE05303D7705FA: {
                    "nonce": 1,
                    "code": f.read(),
                    "storage": storage,
                }
            }
        )

    # Add the withdrawal request contract
    with open(CURRENT_FOLDER / "contracts" / "withdrawal_request.bin", mode="rb") as f:
        new_allocation.update(
            {
                0x09FC772D0857550724B07B850A4323F39112AAAA: {
                    "nonce": 1,
                    "code": f.read(),
                },
            }
        )

    # Add the consolidation request contract
    with open(CURRENT_FOLDER / "contracts" / "consolidation_request.bin", mode="rb") as f:
        new_allocation.update(
            {
                0x01ABEA29659E5E97C95107F20BB753CD3E09BBBB: {
                    "nonce": 1,
                    "code": f.read(),
                },
            }
        )

    # Add the history storage contract
    with open(CURRENT_FOLDER / "contracts" / "history_contract.bin", mode="rb") as f:
        new_allocation.update(
            {
                0x0AAE40965E6800CD9B1F4B05FF21581047E3F91E: {
                    "nonce": 1,
                    "code": f.read(),
                }
            }
        )

    return new_allocation | super(Prague, cls).pre_allocation_blockchain()  # type: ignore

header_requests_required(block_number, timestamp) classmethod

Prague requires that the execution layer header contains the beacon chain requests hash.

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

@classmethod
def header_requests_required(cls, block_number: int, timestamp: int) -> bool:
    """
    Prague requires that the execution layer header contains the beacon
    chain requests hash.
    """
    return True

header_target_blobs_per_block_required(block_number=0, timestamp=0) classmethod

Prague requires that the execution layer header contains the beacon chain target blobs per block.

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

@classmethod
def header_target_blobs_per_block_required(
    cls,
    block_number: int = 0,
    timestamp: int = 0,
) -> bool:
    """
    Prague requires that the execution layer header contains the beacon
    chain target blobs per block.
    """
    return True

engine_new_payload_requests(block_number=0, timestamp=0) classmethod

Starting at Prague, new payloads include the requests hash as a parameter.

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

@classmethod
def engine_new_payload_requests(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """
    Starting at Prague, new payloads include the requests hash as a parameter.
    """
    return True

engine_new_payload_target_blobs_per_block(block_number=0, timestamp=0) classmethod

Starting at Prague, new payloads include the target blobs per block as a parameter.

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

@classmethod
def engine_new_payload_target_blobs_per_block(
    cls, block_number: int = 0, timestamp: int = 0
) -> bool:
    """
    Starting at Prague, new payloads include the target blobs per block as a parameter.
    """
    return True

engine_new_payload_version(block_number=0, timestamp=0) classmethod

Starting at Prague, new payload calls must use version 4

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 Prague, new payload calls must use version 4
    """
    return 4

engine_payload_attribute_target_blobs_per_block(block_number=0, timestamp=0) classmethod

Starting at Prague, payload attributes include the target blobs per block.

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

@classmethod
def engine_payload_attribute_target_blobs_per_block(
    cls, block_number: int = 0, timestamp: int = 0
) -> bool:
    """
    Starting at Prague, payload attributes include the target blobs per block.
    """
    return True

engine_payload_attribute_max_blobs_per_block(block_number=0, timestamp=0) classmethod

Starting at Prague, payload attributes include the max blobs per block.

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

@classmethod
def engine_payload_attribute_max_blobs_per_block(
    cls, block_number: int = 0, timestamp: int = 0
) -> bool:
    """
    Starting at Prague, payload attributes include the max blobs per block.
    """
    return True

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

    @classmethod
    def valid_opcodes(
        cls,
    ) -> List[Opcodes]:
        """
        Returns the list of Opcodes that are valid to work on this fork.
        """
        return [Opcodes.PUSH0] + super(Shanghai, cls).valid_opcodes()

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

valid_opcodes() classmethod

Returns the list of Opcodes that are valid to work on this fork.

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

@classmethod
def valid_opcodes(
    cls,
) -> List[Opcodes]:
    """
    Returns the list of Opcodes that are valid to work on this fork.
    """
    return [Opcodes.PUSH0] + super(Shanghai, cls).valid_opcodes()

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_no_descendants(forks)

Get the forks with no descendants in the inheritance hierarchy.

Source code in src/ethereum_test_forks/helpers.py

def get_forks_with_no_descendants(forks: Set[Fork]) -> Set[Fork]:
    """
    Get the forks with no descendants in the inheritance hierarchy.
    """
    resulting_forks: Set[Fork] = set()
    for fork in forks:
        descendants = False
        for next_fork in forks - {fork}:
            if next_fork > fork:
                descendants = True
                break
        if not descendants:
            resulting_forks = resulting_forks | {fork}
    return resulting_forks

get_forks_with_no_parents(forks)

Get the forks with no parents in the inheritance hierarchy.

Source code in src/ethereum_test_forks/helpers.py

def get_forks_with_no_parents(forks: Set[Fork]) -> Set[Fork]:
    """
    Get the forks with no parents in the inheritance hierarchy.
    """
    resulting_forks: Set[Fork] = set()
    for fork in forks:
        parents = False
        for next_fork in forks - {fork}:
            if next_fork < fork:
                parents = True
                break
        if not parents:
            resulting_forks = resulting_forks | {fork}
    return resulting_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_from_until_fork_set(forks, forks_from, forks_until)

Get the fork range from forks_from to forks_until.

Source code in src/ethereum_test_forks/helpers.py

def get_from_until_fork_set(
    forks: Set[Fork], forks_from: Set[Fork], forks_until: Set[Fork]
) -> Set[Fork]:
    """
    Get the fork range from forks_from to forks_until.
    """
    resulting_set = set()
    for fork_from in forks_from:
        for fork_until in forks_until:
            for fork in forks:
                if fork <= fork_until and fork >= fork_from:
                    resulting_set.add(fork)
    return resulting_set

get_last_descendants(forks, forks_from)

Get the last descendant of a class in the inheritance hierarchy.

Source code in src/ethereum_test_forks/helpers.py

def get_last_descendants(forks: Set[Fork], forks_from: Set[Fork]) -> Set[Fork]:
    """
    Get the last descendant of a class in the inheritance hierarchy.
    """
    resulting_forks: Set[Fork] = set()
    forks = get_forks_with_no_descendants(forks)
    for fork_from in forks_from:
        for fork in forks:
            if fork >= fork_from:
                resulting_forks = resulting_forks | {fork}
    return resulting_forks

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