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:
        """Return value of the attribute at the given block number and timestamp."""
        pass

__call__(block_number=0, timestamp=0)

Return 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:
    """Return 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 [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]:
        """Return 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 [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

Return 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]:
    """Return 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:
        """Return 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_price_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> BlobGasPriceCalculator:
        """Return a callable that calculates the blob gas price at Cancun."""
        min_base_fee_per_blob_gas = cls.min_base_fee_per_blob_gas(block_number, timestamp)
        blob_base_fee_update_fraction = cls.blob_base_fee_update_fraction(block_number, timestamp)

        def fn(*, excess_blob_gas) -> int:
            return fake_exponential(
                min_base_fee_per_blob_gas,
                excess_blob_gas,
                blob_base_fee_update_fraction,
            )

        return fn

    @classmethod
    def excess_blob_gas_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> ExcessBlobGasCalculator:
        """Return a callable that calculates the excess blob gas for a block at Cancun."""
        target_blobs_per_block = cls.target_blobs_per_block(block_number, timestamp)
        blob_gas_per_blob = cls.blob_gas_per_blob(block_number, timestamp)
        target_blob_gas_per_block = target_blobs_per_block * blob_gas_per_blob

        def fn(
            *,
            parent_excess_blob_gas: int | None = None,
            parent_excess_blobs: int | None = None,
            parent_blob_gas_used: int | None = None,
            parent_blob_count: int | None = None,
        ) -> int:
            if parent_excess_blob_gas is None:
                assert parent_excess_blobs is not None, "Parent excess blobs are required"
                parent_excess_blob_gas = parent_excess_blobs * blob_gas_per_blob
            if parent_blob_gas_used is None:
                assert parent_blob_count is not None, "Parent blob count is required"
                parent_blob_gas_used = parent_blob_count * blob_gas_per_blob
            if parent_excess_blob_gas + parent_blob_gas_used < target_blob_gas_per_block:
                return 0
            else:
                return parent_excess_blob_gas + parent_blob_gas_used - target_blob_gas_per_block

        return fn

    @classmethod
    def min_base_fee_per_blob_gas(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """Return the minimum base fee per blob gas for Cancun."""
        return 1

    @classmethod
    def blob_base_fee_update_fraction(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """Return the blob base fee update fraction for Cancun."""
        return 3338477

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

    @classmethod
    def supports_blobs(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """At Cancun, blobs support is enabled."""
        return True

    @classmethod
    def target_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> 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 = 0, timestamp: int = 0) -> int:
        """Blobs are enabled starting from Cancun, with a static max of 6 blobs."""
        return 6

    @classmethod
    def blob_schedule(cls, block_number: int = 0, timestamp: int = 0) -> BlobSchedule | None:
        """
        At Cancun, the fork object runs this routine to get the updated blob
        schedule.
        """
        parent_fork = cls.parent()
        assert parent_fork is not None, "Parent fork must be defined"
        blob_schedule = parent_fork.blob_schedule(block_number, timestamp)
        if blob_schedule is None:
            last_blob_schedule = None
            blob_schedule = BlobSchedule()
        else:
            last_blob_schedule = blob_schedule.last()
        current_blob_schedule = ForkBlobSchedule(
            target_blobs_per_block=cls.target_blobs_per_block(block_number, timestamp),
            max_blobs_per_block=cls.max_blobs_per_block(block_number, timestamp),
            base_fee_update_fraction=cls.blob_base_fee_update_fraction(block_number, timestamp),
        )
        if last_blob_schedule is None or last_blob_schedule != current_blob_schedule:
            blob_schedule.append(fork=cls.__name__, schedule=current_blob_schedule)
        return blob_schedule

    @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]:
        """From 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:
        """From Cancun, payloads must have blob hashes."""
        return True

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

    @classmethod
    def valid_opcodes(
        cls,
    ) -> List[Opcodes]:
        """Return 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

Return 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:
    """Return 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_price_calculator(block_number=0, timestamp=0) classmethod

Return a callable that calculates the blob gas price at Cancun.

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

@classmethod
def blob_gas_price_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> BlobGasPriceCalculator:
    """Return a callable that calculates the blob gas price at Cancun."""
    min_base_fee_per_blob_gas = cls.min_base_fee_per_blob_gas(block_number, timestamp)
    blob_base_fee_update_fraction = cls.blob_base_fee_update_fraction(block_number, timestamp)

    def fn(*, excess_blob_gas) -> int:
        return fake_exponential(
            min_base_fee_per_blob_gas,
            excess_blob_gas,
            blob_base_fee_update_fraction,
        )

    return fn

excess_blob_gas_calculator(block_number=0, timestamp=0) classmethod

Return a callable that calculates the excess blob gas for a block at Cancun.

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

@classmethod
def excess_blob_gas_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> ExcessBlobGasCalculator:
    """Return a callable that calculates the excess blob gas for a block at Cancun."""
    target_blobs_per_block = cls.target_blobs_per_block(block_number, timestamp)
    blob_gas_per_blob = cls.blob_gas_per_blob(block_number, timestamp)
    target_blob_gas_per_block = target_blobs_per_block * blob_gas_per_blob

    def fn(
        *,
        parent_excess_blob_gas: int | None = None,
        parent_excess_blobs: int | None = None,
        parent_blob_gas_used: int | None = None,
        parent_blob_count: int | None = None,
    ) -> int:
        if parent_excess_blob_gas is None:
            assert parent_excess_blobs is not None, "Parent excess blobs are required"
            parent_excess_blob_gas = parent_excess_blobs * blob_gas_per_blob
        if parent_blob_gas_used is None:
            assert parent_blob_count is not None, "Parent blob count is required"
            parent_blob_gas_used = parent_blob_count * blob_gas_per_blob
        if parent_excess_blob_gas + parent_blob_gas_used < target_blob_gas_per_block:
            return 0
        else:
            return parent_excess_blob_gas + parent_blob_gas_used - target_blob_gas_per_block

    return fn

min_base_fee_per_blob_gas(block_number=0, timestamp=0) classmethod

Return the minimum base fee per blob gas for Cancun.

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

@classmethod
def min_base_fee_per_blob_gas(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """Return the minimum base fee per blob gas for Cancun."""
    return 1

blob_base_fee_update_fraction(block_number=0, timestamp=0) classmethod

Return the blob base fee update fraction for Cancun.

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

@classmethod
def blob_base_fee_update_fraction(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """Return the blob base fee update fraction for Cancun."""
    return 3338477

blob_gas_per_blob(block_number=0, timestamp=0) 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 = 0, timestamp: int = 0) -> int:
    """Blobs are enabled starting from Cancun."""
    return 2**17

supports_blobs(block_number=0, timestamp=0) classmethod

At Cancun, blobs support is enabled.

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

@classmethod
def supports_blobs(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """At Cancun, blobs support is enabled."""
    return True

target_blobs_per_block(block_number=0, timestamp=0) 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 = 0, timestamp: int = 0) -> int:
    """Blobs are enabled starting from Cancun, with a static target of 3 blobs."""
    return 3

max_blobs_per_block(block_number=0, timestamp=0) 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 = 0, timestamp: int = 0) -> int:
    """Blobs are enabled starting from Cancun, with a static max of 6 blobs."""
    return 6

blob_schedule(block_number=0, timestamp=0) classmethod

At Cancun, the fork object runs this routine to get the updated blob schedule.

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

@classmethod
def blob_schedule(cls, block_number: int = 0, timestamp: int = 0) -> BlobSchedule | None:
    """
    At Cancun, the fork object runs this routine to get the updated blob
    schedule.
    """
    parent_fork = cls.parent()
    assert parent_fork is not None, "Parent fork must be defined"
    blob_schedule = parent_fork.blob_schedule(block_number, timestamp)
    if blob_schedule is None:
        last_blob_schedule = None
        blob_schedule = BlobSchedule()
    else:
        last_blob_schedule = blob_schedule.last()
    current_blob_schedule = ForkBlobSchedule(
        target_blobs_per_block=cls.target_blobs_per_block(block_number, timestamp),
        max_blobs_per_block=cls.max_blobs_per_block(block_number, timestamp),
        base_fee_update_fraction=cls.blob_base_fee_update_fraction(block_number, timestamp),
    )
    if last_blob_schedule is None or last_blob_schedule != current_blob_schedule:
        blob_schedule.append(fork=cls.__name__, schedule=current_blob_schedule)
    return blob_schedule

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

From 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]:
    """From Cancun, new payload calls must use version 3."""
    return 3

engine_new_payload_blob_hashes(block_number=0, timestamp=0) classmethod

From 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:
    """From Cancun, payloads must have blob hashes."""
    return True

engine_new_payload_beacon_root(block_number=0, timestamp=0) classmethod

From 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:
    """From Cancun, payloads must have a parent beacon block root."""
    return True

valid_opcodes() classmethod

Return 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]:
    """Return 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]:
        """Return 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

Return 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]:
    """Return 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:
        """Return 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:
        """Return 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:
        """Return 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:
        """Return 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=0,
            R_AUTHORIZATION_EXISTING_AUTHORITY=0,
        )

    @classmethod
    def memory_expansion_gas_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> MemoryExpansionGasCalculator:
        """Return 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:
        """
        Return 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:
        """Return 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_price_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> BlobGasPriceCalculator:
        """Return a callable that calculates the blob gas price at a given fork."""
        raise NotImplementedError(f"Blob gas price calculator is not supported in {cls.name()}")

    @classmethod
    def excess_blob_gas_calculator(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> ExcessBlobGasCalculator:
        """Return a callable that calculates the excess blob gas for a block at a given fork."""
        raise NotImplementedError(f"Excess blob gas calculator is not supported in {cls.name()}")

    @classmethod
    def min_base_fee_per_blob_gas(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """Return the amount of blob gas used per blob at a given fork."""
        raise NotImplementedError(f"Base fee per blob gas is not supported in {cls.name()}")

    @classmethod
    def blob_base_fee_update_fraction(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """Return the blob base fee update fraction at a given fork."""
        raise NotImplementedError(
            f"Blob base fee update fraction is not supported in {cls.name()}"
        )

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

    @classmethod
    def supports_blobs(cls, block_number: int = 0, timestamp: int = 0) -> bool:
        """Blobs are not supported at Frontier."""
        return False

    @classmethod
    def target_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """Return the target number of blobs per block at a given fork."""
        raise NotImplementedError(f"Target blobs per block is not supported in {cls.name()}")

    @classmethod
    def max_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """Return the max number of blobs per block at a given fork."""
        raise NotImplementedError(f"Max blobs per block is not supported in {cls.name()}")

    @classmethod
    def blob_schedule(cls, block_number: int = 0, timestamp: int = 0) -> BlobSchedule | None:
        """At genesis, no blob schedule is used."""
        return None

    @classmethod
    def header_requests_required(cls, block_number: int = 0, timestamp: int = 0) -> 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 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]]:
        """Return list of call opcodes supported by the fork."""
        return [
            (Opcodes.CALL, EVMCodeType.LEGACY),
            (Opcodes.CALLCODE, EVMCodeType.LEGACY),
        ]

    @classmethod
    def valid_opcodes(
        cls,
    ) -> List[Opcodes]:
        """Return 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:
        """
        Return whether the fork expects pre-allocation of accounts.

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

    @classmethod
    def pre_allocation_blockchain(cls) -> Mapping:
        """
        Return 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

Return 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:
    """Return 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

Return 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:
    """Return 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

Return 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:
    """Return 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

Return 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:
    """Return 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=0,
        R_AUTHORIZATION_EXISTING_AUTHORITY=0,
    )

memory_expansion_gas_calculator(block_number=0, timestamp=0) classmethod

Return 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:
    """Return 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

Return 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:
    """
    Return 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

Return 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:
    """Return 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_price_calculator(block_number=0, timestamp=0) classmethod

Return a callable that calculates the blob gas price at a given fork.

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

@classmethod
def blob_gas_price_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> BlobGasPriceCalculator:
    """Return a callable that calculates the blob gas price at a given fork."""
    raise NotImplementedError(f"Blob gas price calculator is not supported in {cls.name()}")

excess_blob_gas_calculator(block_number=0, timestamp=0) classmethod

Return a callable that calculates the excess blob gas for a block at a given fork.

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

@classmethod
def excess_blob_gas_calculator(
    cls, block_number: int = 0, timestamp: int = 0
) -> ExcessBlobGasCalculator:
    """Return a callable that calculates the excess blob gas for a block at a given fork."""
    raise NotImplementedError(f"Excess blob gas calculator is not supported in {cls.name()}")

min_base_fee_per_blob_gas(block_number=0, timestamp=0) classmethod

Return the amount of blob gas used per blob at a given fork.

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

@classmethod
def min_base_fee_per_blob_gas(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """Return the amount of blob gas used per blob at a given fork."""
    raise NotImplementedError(f"Base fee per blob gas is not supported in {cls.name()}")

blob_base_fee_update_fraction(block_number=0, timestamp=0) classmethod

Return the blob base fee update fraction at a given fork.

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

@classmethod
def blob_base_fee_update_fraction(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """Return the blob base fee update fraction at a given fork."""
    raise NotImplementedError(
        f"Blob base fee update fraction is not supported in {cls.name()}"
    )

blob_gas_per_blob(block_number=0, timestamp=0) classmethod

Return the amount of blob gas used per blob at a given fork.

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

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

supports_blobs(block_number=0, timestamp=0) classmethod

Blobs are not supported at Frontier.

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

@classmethod
def supports_blobs(cls, block_number: int = 0, timestamp: int = 0) -> bool:
    """Blobs are not supported at Frontier."""
    return False

target_blobs_per_block(block_number=0, timestamp=0) classmethod

Return the target number of blobs per block at a given fork.

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

@classmethod
def target_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """Return the target number of blobs per block at a given fork."""
    raise NotImplementedError(f"Target blobs per block is not supported in {cls.name()}")

max_blobs_per_block(block_number=0, timestamp=0) classmethod

Return the max number of blobs per block at a given fork.

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

@classmethod
def max_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """Return the max number of blobs per block at a given fork."""
    raise NotImplementedError(f"Max blobs per block is not supported in {cls.name()}")

blob_schedule(block_number=0, timestamp=0) classmethod

At genesis, no blob schedule is used.

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

@classmethod
def blob_schedule(cls, block_number: int = 0, timestamp: int = 0) -> BlobSchedule | None:
    """At genesis, no blob schedule is used."""
    return None

header_requests_required(block_number=0, timestamp=0) 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 = 0, timestamp: int = 0) -> 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

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

Return 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]]:
    """Return list of call opcodes supported by the fork."""
    return [
        (Opcodes.CALL, EVMCodeType.LEGACY),
        (Opcodes.CALLCODE, EVMCodeType.LEGACY),
    ]

valid_opcodes() classmethod

Return 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]:
    """Return 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

Return 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:
    """
    Return whether the fork expects pre-allocation of accounts.

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

pre_allocation_blockchain() classmethod

Return 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:
    """
    Return 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 [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]:
        """Return 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 [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

Return 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]:
    """Return 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]:
        """Return 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

Return 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]:
    """Return 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:
        """Header must contain the Base Fee 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]:
        """Return 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

Header must contain the Base Fee 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:
    """Header must contain the Base Fee 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

Return 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]:
    """Return 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:
        """
        Flag that the fork has not been deployed to mainnet; it is under active
        development.
        """
        return False

    @classmethod
    def solc_min_version(cls) -> Version:
        """Return 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

Flag 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:
    """
    Flag that the fork has not been deployed to mainnet; it is under active
    development.
    """
    return False

solc_min_version() classmethod

Return 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:
    """Return 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]:
        """From 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

From 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]:
    """From 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:
        """
        Flag that the fork has not been deployed to mainnet; it is under active
        development.
        """
        return False

    @classmethod
    def solc_min_version(cls) -> Version:
        """Return 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 [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,
            G_AUTHORIZATION=25_000,
            R_AUTHORIZATION_EXISTING_AUTHORITY=12_500,
        )

    @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(0x0C15F14308530B7CDB8460094BBB9CC28B9AAAAA),
            Address(0x00431F263CE400F4455C2DCF564E53007CA4BBBB),
            Address(0x0F792BE4B0C0CB4DAE440EF133E90C0ECD48CCCC),
        ] + 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:
        """
        Return 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:
        """On 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 blob_base_fee_update_fraction(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """Return the blob base fee update fraction for Prague."""
        return 5007716

    @classmethod
    def target_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """Target blob count of 6 for Prague."""
        return 6

    @classmethod
    def max_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
        """Max blob count of 9 for Prague."""
        return 9

    @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(
                {
                    0x0C15F14308530B7CDB8460094BBB9CC28B9AAAAA: {
                        "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(
                {
                    0x00431F263CE400F4455C2DCF564E53007CA4BBBB: {
                        "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(
                {
                    0x0F792BE4B0C0CB4DAE440EF133E90C0ECD48CCCC: {
                        "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 = 0, timestamp: int = 0) -> bool:
        """
        Prague requires that the execution layer header contains the beacon
        chain requests hash.
        """
        return True

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

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

    @classmethod
    def engine_forkchoice_updated_version(
        cls, block_number: int = 0, timestamp: int = 0
    ) -> Optional[int]:
        """At Prague, version number of NewPayload and ForkchoiceUpdated diverge."""
        return 3

is_deployed() classmethod

Flag 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:
    """
    Flag that the fork has not been deployed to mainnet; it is under active
    development.
    """
    return False

solc_min_version() classmethod

Return 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:
    """Return 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 [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,
        G_AUTHORIZATION=25_000,
        R_AUTHORIZATION_EXISTING_AUTHORITY=12_500,
    )

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(0x0C15F14308530B7CDB8460094BBB9CC28B9AAAAA),
        Address(0x00431F263CE400F4455C2DCF564E53007CA4BBBB),
        Address(0x0F792BE4B0C0CB4DAE440EF133E90C0ECD48CCCC),
    ] + 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

Return 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:
    """
    Return 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

On 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:
    """On 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

blob_base_fee_update_fraction(block_number=0, timestamp=0) classmethod

Return the blob base fee update fraction for Prague.

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

@classmethod
def blob_base_fee_update_fraction(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """Return the blob base fee update fraction for Prague."""
    return 5007716

target_blobs_per_block(block_number=0, timestamp=0) classmethod

Target blob count of 6 for Prague.

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

@classmethod
def target_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """Target blob count of 6 for Prague."""
    return 6

max_blobs_per_block(block_number=0, timestamp=0) classmethod

Max blob count of 9 for Prague.

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

@classmethod
def max_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
    """Max blob count of 9 for Prague."""
    return 9

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(
            {
                0x0C15F14308530B7CDB8460094BBB9CC28B9AAAAA: {
                    "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(
            {
                0x00431F263CE400F4455C2DCF564E53007CA4BBBB: {
                    "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(
            {
                0x0F792BE4B0C0CB4DAE440EF133E90C0ECD48CCCC: {
                    "nonce": 1,
                    "code": f.read(),
                }
            }
        )

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

header_requests_required(block_number=0, timestamp=0) 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 = 0, timestamp: int = 0) -> bool:
    """
    Prague requires that the execution layer header contains the beacon
    chain requests hash.
    """
    return True

engine_new_payload_requests(block_number=0, timestamp=0) classmethod

From 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:
    """From Prague, new payloads include the requests hash as a parameter."""
    return True

engine_new_payload_version(block_number=0, timestamp=0) classmethod

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

engine_forkchoice_updated_version(block_number=0, timestamp=0) classmethod

At Prague, version number of NewPayload and ForkchoiceUpdated diverge.

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 Prague, version number of NewPayload and ForkchoiceUpdated diverge."""
    return 3

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]:
        """From Shanghai, new payload calls must use version 2."""
        return 2

    @classmethod
    def valid_opcodes(
        cls,
    ) -> List[Opcodes]:
        """Return 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

From 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]:
    """From Shanghai, new payload calls must use version 2."""
    return 2

valid_opcodes() classmethod

Return 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]:
    """Return 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

CancunToPragueAtTime15k

Bases: Cancun

Cancun to Prague transition at Timestamp 15k.

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

@transition_fork(to_fork=Prague, at_timestamp=15_000)
class CancunToPragueAtTime15k(Cancun):
    """Cancun to Prague transition at Timestamp 15k."""

    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):
        """Initialize the InvalidForkError exception."""
        super().__init__(message)

__init__(message)

Initialize the InvalidForkError exception.

Source code in src/ethereum_test_forks/helpers.py

def __init__(self, message):
    """Initialize the InvalidForkError exception."""
    super().__init__(message)

forks_from(fork, deployed_only=True)

Return 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]:
    """Return 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)

Return 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]:
    """
    Return 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)

Return 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]:
    """
    Return 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()

Return 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]:
    """
    Return 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()

Return 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]:
    """
    Return 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()

Return 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]:
    """
    Return 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 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 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 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 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)

Return 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]:
    """Return 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)

Return 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]:
    """Return 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 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 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 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 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()

Return all the transition forks.

Source code in src/ethereum_test_forks/helpers.py

def get_transition_forks() -> Set[Fork]:
    """Return all the transition forks."""
    transition_forks: Set[Fork] = set()

    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.add(fork)

    return transition_forks

transition_fork_from_to(fork_from, fork_to)

Return 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:
    """
    Return 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)

Return transition fork that transitions to the specified fork.

Source code in src/ethereum_test_forks/helpers.py

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

    return transition_forks