Merge pull request #2016 from carver/tests-9.0.4

Update ethereum/tests to 9.0.4

Author: carver

eth/tools/_utils/normalization.py

@@ -465,17 +465,39 @@ def normalize_vmtest_fixture(fixture: Dict[str, Any]) -> Iterable[Tuple[str, Any
 
 
 def normalize_signed_transaction(transaction: Dict[str, Any]) -> Dict[str, Any]:
-    return {
+    normalized_universal_transaction = {
         'data': robust_decode_hex(transaction['data']),
         'gasLimit': to_int(transaction['gasLimit']),
-        'gasPrice': to_int(transaction['gasPrice']),
         'nonce': to_int(transaction['nonce']),
         'r': to_int(transaction['r']),
         's': to_int(transaction['s']),
         'v': to_int(transaction['v']),
         'to': decode_hex(transaction['to']),
         'value': to_int(transaction['value']),
     }
+    if 'type' in transaction:
+        type_id = to_int(transaction['type'])
+        if type_id == 1:
+            custom_fields = {
+                'type': type_id,
+                'gasPrice': to_int(transaction['gasPrice']),
+                'chainId': to_int(transaction['chainId']),
+            }
+        elif type_id == 2:
+            custom_fields = {
+                'type': type_id,
+                'chainId': to_int(transaction['chainId']),
+                'maxFeePerGas': to_int(transaction['maxFeePerGas']),
+                'maxPriorityFeePerGas': to_int(transaction['maxPriorityFeePerGas']),
+            }
+        else:
+            raise ValidationError(f"Did not recognize transaction type {type_id}")
+    else:
+        custom_fields = {
+            'gasPrice': to_int(transaction['gasPrice']),
+        }
+
+    return merge(normalized_universal_transaction, custom_fields)
 
 
 @curry

eth/tools/fixtures/generation.py

@@ -1,5 +1,4 @@
 import hashlib
-import os
 
 from typing import (
     Any,
@@ -14,7 +13,6 @@
 
 from .loading import (
     find_fixtures,
-    find_fixture_files,
 )
 
 
@@ -59,31 +57,8 @@ def generate_fixture_tests(metafunc: Any,
        fixtures (such as expanding the statetest fixtures to be multiple tests for
        each fork.
     """
-    fixture_namespace = os.path.basename(base_fixture_path)
-
     if 'fixture_data' in metafunc.fixturenames:
-        all_fixture_paths = find_fixture_files(base_fixture_path)
-        current_file_hash = get_fixtures_file_hash(all_fixture_paths)
-
-        data_cache_key = f'pyevm/statetest/fixtures/{fixture_namespace}/data'
-        file_hash_cache_key = f'pyevm/statetest/fixtures/{fixture_namespace}/data-hash'
-
-        cached_file_hash = metafunc.config.cache.get(file_hash_cache_key, None)
-        cached_fixture_data = metafunc.config.cache.get(data_cache_key, None)
-
-        bust_cache = any((
-            cached_file_hash is None,
-            cached_fixture_data is None,
-            cached_file_hash != current_file_hash,
-        ))
-
-        if bust_cache:
-            all_fixtures = find_fixtures(base_fixture_path)
-
-            metafunc.config.cache.set(data_cache_key, all_fixtures)
-            metafunc.config.cache.set(file_hash_cache_key, current_file_hash)
-        else:
-            all_fixtures = cached_fixture_data
+        all_fixtures = find_fixtures(base_fixture_path)
 
         if not all_fixtures:
             raise AssertionError(

eth/tools/fixtures/helpers.py

@@ -48,6 +48,7 @@
     SpuriousDragonVM,
     IstanbulVM,
     BerlinVM,
+    LondonVM,
 )
 
 
@@ -162,6 +163,11 @@ def chain_vm_configuration(fixture: Dict[str, Any]) -> Iterable[Tuple[int, Type[
             (0, ByzantiumVM),
             (5, PetersburgVM),
         )
+    elif network == 'BerlinToLondonAt5':
+        return (
+            (0, BerlinVM),
+            (5, LondonVM),
+        )
     else:
         raise ValueError(f"Network {network} does not match any known VM rules")
 

eth/tools/fixtures/loading.py

@@ -101,7 +101,7 @@ def filter_fixtures(all_fixtures: Iterable[Any],
             if mark:
                 yield pytest.param(
                     (fixture_path, *fixture_data[1:]),
-                    marks=mark,
+                    marks=mark,  # type: ignore  # we don't annotate the test code that calls this
                 )
                 continue
 

eth/vm/forks/berlin/receipts.py

@@ -43,6 +43,7 @@ class TypedReceipt(ReceiptAPI, ReceiptDecoderAPI):
     type_id: int
     rlp_type = Binary(min_length=1)  # must have at least one byte for the type
     _inner: ReceiptAPI
+    codecs = TYPED_RECEIPT_BODY_CODECS
 
     def __init__(self, type_id: int, proxy_target: ReceiptAPI) -> None:
         self.type_id = type_id
@@ -69,8 +70,8 @@ def encode(self) -> bytes:
 
     @classmethod
     def get_payload_codec(cls, type_id: int) -> Type[ReceiptDecoderAPI]:
-        if type_id in TYPED_RECEIPT_BODY_CODECS:
-            return TYPED_RECEIPT_BODY_CODECS[type_id]
+        if type_id in cls.codecs:
+            return cls.codecs[type_id]
         elif type_id in VALID_TRANSACTION_TYPES:
             raise UnrecognizedTransactionType(type_id, "Unknown receipt type")
         else:
@@ -124,23 +125,23 @@ def __eq__(self, other: Any) -> bool:
 
 class BerlinReceiptBuilder(ReceiptBuilderAPI):
     legacy_sedes = Receipt
-    codecs = TYPED_RECEIPT_BODY_CODECS
+    typed_receipt_class = TypedReceipt
 
     @classmethod
     def decode(cls, encoded: bytes) -> ReceiptAPI:
         if len(encoded) == 0:
             raise ValidationError("Encoded receipt was empty, which makes it invalid")
 
         type_id = to_int(encoded[0])
-        if type_id in cls.codecs:
-            return TypedReceipt.decode(encoded)
+        if type_id in cls.typed_receipt_class.codecs:
+            return cls.typed_receipt_class.decode(encoded)
         else:
             return rlp.decode(encoded, sedes=cls.legacy_sedes)
 
     @classmethod
     def deserialize(cls, encoded: DecodedZeroOrOneLayerRLP) -> ReceiptAPI:
         if isinstance(encoded, bytes):
-            return TypedReceipt.deserialize(encoded)
+            return cls.typed_receipt_class.deserialize(encoded)
         else:
             return cls.legacy_sedes.deserialize(encoded)
 

eth/vm/forks/berlin/transactions.py

@@ -63,7 +63,7 @@
     VALID_TRANSACTION_TYPES,
 )
 from .receipts import (
-    TypedReceipt,
+    BerlinReceiptBuilder,
 )
 
 
@@ -246,6 +246,7 @@ class TypedTransaction(SignedTransactionMethods, SignedTransactionAPI, Transacti
     decoders: Dict[int, Type[TransactionDecoderAPI]] = {
         ACCESS_LIST_TRANSACTION_TYPE: AccessListPayloadDecoder,
     }
+    receipt_builder = BerlinReceiptBuilder
 
     def __init__(self, type_id: int, proxy_target: SignedTransactionAPI) -> None:
         self.type_id = type_id
@@ -373,7 +374,7 @@ def make_receipt(
 
         inner_receipt = self._inner.make_receipt(status, gas_used, log_entries)
 
-        return TypedReceipt(ACCESS_LIST_TRANSACTION_TYPE, inner_receipt)
+        return self.receipt_builder.typed_receipt_class(self.type_id, inner_receipt)
 
     def __hash__(self) -> int:
         return hash((self.type_id, self._inner))

eth/vm/forks/london/blocks.py

@@ -84,10 +84,10 @@ class LondonMiningHeader(rlp.Serializable, MiningHeaderAPI):
 
 
 class LondonBlockHeader(rlp.Serializable, BlockHeaderAPI):
-    fields = UNMINED_LONDON_HEADER_FIELDS + [
+    fields = UNMINED_LONDON_HEADER_FIELDS[:-1] + [
         ('mix_hash', binary),
         ('nonce', Binary(8, allow_empty=True)),
-    ]
+    ] + UNMINED_LONDON_HEADER_FIELDS[-1:]
 
     def __init__(self,
                  difficulty: int,
@@ -144,7 +144,8 @@ def hash(self) -> Hash32:
 
     @property
     def mining_hash(self) -> Hash32:
-        result = keccak(rlp.encode(self[:-2], LondonMiningHeader))
+        non_pow_fields = self[:-3] + self[-1:]
+        result = keccak(rlp.encode(non_pow_fields, LondonMiningHeader))
         return cast(Hash32, result)
 
     @property

eth/vm/forks/london/receipts.py

@@ -7,7 +7,8 @@
     Receipt,
 )
 from eth.vm.forks.berlin.receipts import (
-    BerlinReceiptBuilder
+    BerlinReceiptBuilder,
+    TypedReceipt as BerlinTypedReceipt,
 )
 from eth.vm.forks.berlin.constants import (
     ACCESS_LIST_TRANSACTION_TYPE,
@@ -16,8 +17,12 @@
 from .constants import DYNAMIC_FEE_TRANSACTION_TYPE
 
 
-class LondonReceiptBuilder(BerlinReceiptBuilder):
+class LondonTypedReceipt(BerlinTypedReceipt):
     codecs: Dict[int, Type[Receipt]] = {
         ACCESS_LIST_TRANSACTION_TYPE: Receipt,
         DYNAMIC_FEE_TRANSACTION_TYPE: Receipt,
     }
+
+
+class LondonReceiptBuilder(BerlinReceiptBuilder):
+    typed_receipt_class = LondonTypedReceipt

eth/vm/forks/london/transactions.py

@@ -54,6 +54,7 @@
 )
 
 from .constants import DYNAMIC_FEE_TRANSACTION_TYPE
+from .receipts import LondonReceiptBuilder
 
 
 class LondonLegacyTransaction(BerlinLegacyTransaction):
@@ -218,6 +219,7 @@ class LondonTypedTransaction(TypedTransaction):
         ACCESS_LIST_TRANSACTION_TYPE: AccessListPayloadDecoder,
         DYNAMIC_FEE_TRANSACTION_TYPE: DynamicFeePayloadDecoder,
     }
+    receipt_builder = LondonReceiptBuilder
 
 
 class LondonTransactionBuilder(BerlinTransactionBuilder):