Skip to content

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
16
17
18
19
20
21
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
19
20
21
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
795
796
797
798
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
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
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
725
726
727
728
@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
730
731
732
733
@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
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
@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
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
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
612
613
614
615
616
617
618
@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
620
621
622
623
624
625
626
627
628
629
@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
631
632
633
634
635
636
637
638
@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
640
641
642
643
644
645
@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
 860
 861
 862
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
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
863
864
865
866
@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
868
869
870
871
@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
873
874
875
876
@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
878
879
880
881
@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
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
@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
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
@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
929
930
931
932
@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
934
935
936
937
@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
939
940
941
942
@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
944
945
946
947
@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
949
950
951
952
@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
954
955
956
957
@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
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
@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
982
983
984
985
@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
987
988
989
990
@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
992
993
994
995
@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
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
@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
1013
1014
1015
1016
1017
1018
@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
1020
1021
1022
1023
@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
1025
1026
1027
1028
@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
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
@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
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
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
651
652
653
654
655
656
657
@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
659
660
661
662
663
664
665
666
@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
668
669
670
671
672
673
674
675
676
677
678
679
@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
682
683
684
685
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
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
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
35
36
37
38
39
40
@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
42
43
44
45
46
47
@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
49
50
51
52
@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
54
55
56
57
@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
59
60
61
62
@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
64
65
66
67
@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
69
70
71
72
@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
74
75
76
77
@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
79
80
81
82
@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
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
@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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
@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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
@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
171
172
173
174
175
176
177
178
179
180
@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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
@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
213
214
215
216
217
218
@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
220
221
222
223
224
225
@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
227
228
229
230
@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
232
233
234
235
236
237
@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
239
240
241
242
@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
244
245
246
247
@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
249
250
251
252
@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
254
255
256
257
@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
259
260
261
262
@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
264
265
266
267
@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
269
270
271
272
273
274
@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
276
277
278
279
@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
281
282
283
284
@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
286
287
288
289
@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
291
292
293
294
@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
296
297
298
299
300
301
302
303
@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
305
306
307
308
309
310
@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
312
313
314
315
316
317
@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
319
320
321
322
323
324
@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
326
327
328
329
330
331
@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
333
334
335
336
337
338
339
@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
341
342
343
344
@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
346
347
348
349
@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
351
352
353
354
@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
356
357
358
359
@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
361
362
363
364
@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
366
367
368
369
370
371
372
373
374
@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
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
@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
513
514
515
516
517
518
519
520
@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
522
523
524
525
@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
527
528
529
530
531
532
533
534
@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
536
537
538
539
540
541
542
543
@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
801
802
803
804
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
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
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
549
550
551
552
553
554
555
556
557
@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
559
560
561
562
563
564
565
566
@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
568
569
570
571
572
573
@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
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
@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
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
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
691
692
693
694
@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
696
697
698
699
700
701
@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
703
704
705
706
707
708
709
710
711
712
@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
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
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
771
772
773
774
@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
776
777
778
779
@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
781
782
783
784
@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
786
787
788
789
790
791
@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
716
717
718
719
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
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
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
1347
1348
1349
1350
1351
1352
1353
@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
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
@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
1366
1367
1368
1369
1370
1371
1372
@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
1374
1375
1376
1377
@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
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
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
814
815
816
817
@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
819
820
821
822
@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
824
825
826
827
@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
829
830
831
832
833
834
@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
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087