address reviews

Author: RazorClient

packages/testing/src/execution_testing/ssz/__init__.py

@@ -13,15 +13,6 @@
     MAX_EXTRA_DATA_BYTES,
     MAX_TXS_PER_PAYLOAD,
     MAX_WITHDRAWALS_PER_PAYLOAD,
-    Address,
-    Bloom,
-    Bytes4,
-    Bytes8,
-    Bytes32,
-    Bytes48,
-    Hash32,
-    Root,
-    VersionedHash,
 )
 from .containers import (
     BUILT_PAYLOAD_BY_FORK,
@@ -97,6 +88,17 @@
     deterministic_seed,
     get_random_ssz_object,
 )
+from .ssz_types import (
+    Address,
+    Bloom,
+    Bytes4,
+    Bytes8,
+    Bytes32,
+    Bytes48,
+    Hash32,
+    Root,
+    VersionedHash,
+)
 
 ViewT = TypeVar("ViewT", bound=View)
 
@@ -285,8 +287,6 @@ def _opt_bytes(value: bytes | None) -> bytes | None:
     "PayloadAttributesPrague",
     "PayloadAttributesShanghai",
     "PayloadStatus",
-    "REFERENCE_SPEC_GIT_PATH",
-    "REFERENCE_SPEC_VERSION",
     "RandomizationMode",
     "Root",
     "VersionedHash",

packages/testing/src/execution_testing/ssz/constants.py

@@ -1,6 +1,4 @@
-"""SSZ size limits and byte-vector aliases for the REST+SSZ Engine API."""
-
-from remerkleable.byte_arrays import ByteVector
+"""SSZ size limits for the REST+SSZ Engine API."""
 
 # Payload / envelope limits.
 MAX_BYTES_PER_TX = 2**30
@@ -36,39 +34,3 @@
 MAX_CLIENT_VERSIONS = 4
 MAX_CAPABILITY_NAME_LENGTH = 64
 MAX_CAPABILITIES = 64
-
-
-class Hash32(ByteVector[32]):
-    """A 32-byte hash (`Hash32`, `Root` and `Bytes32` share this layout)."""
-
-
-class Bytes32(ByteVector[32]):
-    """A 32-byte fixed vector."""
-
-
-class Root(ByteVector[32]):
-    """A 32-byte merkle root."""
-
-
-class Address(ByteVector[20]):
-    """A 20-byte execution-layer address."""
-
-
-class Bloom(ByteVector[BYTES_PER_LOGS_BLOOM]):
-    """A 256-byte logs bloom filter."""
-
-
-class VersionedHash(ByteVector[32]):
-    """An EIP-4844 versioned blob hash."""
-
-
-class Bytes8(ByteVector[8]):
-    """An 8-byte value (e.g. `payload_id`)."""
-
-
-class Bytes4(ByteVector[4]):
-    """A 4-byte value (e.g. a client commit hash)."""
-
-
-class Bytes48(ByteVector[48]):
-    """A 48-byte value (KZG commitments and proofs)."""

packages/testing/src/execution_testing/ssz/containers.py

@@ -30,6 +30,8 @@
     MAX_EXTRA_DATA_BYTES,
     MAX_TXS_PER_PAYLOAD,
     MAX_WITHDRAWALS_PER_PAYLOAD,
+)
+from .ssz_types import (
     Address,
     Bloom,
     Bytes4,

packages/testing/src/execution_testing/ssz/ssz_types.py

@@ -0,0 +1,41 @@
+"""Byte-vector type aliases for the REST+SSZ Engine API."""
+
+from remerkleable.byte_arrays import ByteVector
+
+from .constants import BYTES_PER_LOGS_BLOOM
+
+
+class Hash32(ByteVector[32]):
+    """A 32-byte hash (`Hash32`, `Root` and `Bytes32` share this layout)."""
+
+
+class Bytes32(ByteVector[32]):
+    """A 32-byte fixed vector."""
+
+
+class Root(ByteVector[32]):
+    """A 32-byte merkle root."""
+
+
+class Address(ByteVector[20]):
+    """A 20-byte execution-layer address."""
+
+
+class Bloom(ByteVector[BYTES_PER_LOGS_BLOOM]):
+    """A 256-byte logs bloom filter."""
+
+
+class VersionedHash(ByteVector[32]):
+    """An EIP-4844 versioned blob hash."""
+
+
+class Bytes8(ByteVector[8]):
+    """An 8-byte value (e.g. `payload_id`)."""
+
+
+class Bytes4(ByteVector[4]):
+    """A 4-byte value (e.g. a client commit hash)."""
+
+
+class Bytes48(ByteVector[48]):
+    """A 48-byte value (KZG commitments and proofs)."""

packages/testing/src/execution_testing/ssz/tests/test_containers.py

@@ -1,5 +1,7 @@
 """Round-trip and structural tests for the SSZ containers."""
 
+from remerkleable.basic import uint64, uint256
+
 from .. import decode_bytes, encode_bytes, hash_tree_root
 from ..containers import (
     EXECUTION_PAYLOAD_BY_FORK,
@@ -8,6 +10,7 @@
     ExecutionPayloadEnvelopeAmsterdam,
     Withdrawal,
 )
+from ..ssz_types import Address, Bloom, Bytes32, Hash32, Root
 
 TRANSACTIONS = [
     bytes.fromhex("02f86b01"),
@@ -18,43 +21,43 @@
 
 def _withdrawal() -> Withdrawal:
     return Withdrawal(
-        index=7,
-        validator_index=42,
-        address=bytes.fromhex("11" * 20),
-        amount=32_000_000_000,
+        index=uint64(7),
+        validator_index=uint64(42),
+        address=Address(bytes.fromhex("11" * 20)),
+        amount=uint64(32_000_000_000),
     )
 
 
-def _max_payload() -> ExecutionPayloadAmsterdam:
-    """The maximal (Amsterdam) payload: populated, carrying every field."""
+def _random_payload() -> ExecutionPayloadAmsterdam:
+    """A fully-populated payload carrying every field of the latest fork."""
     return ExecutionPayloadAmsterdam(
-        parent_hash=bytes.fromhex("aa" * 32),
-        fee_recipient=bytes.fromhex("bb" * 20),
-        state_root=bytes.fromhex("cc" * 32),
-        receipts_root=bytes.fromhex("dd" * 32),
-        logs_bloom=bytes.fromhex("00" * 256),
-        prev_randao=bytes.fromhex("ee" * 32),
-        block_number=21_000_000,
-        gas_limit=30_000_000,
-        gas_used=21_000,
-        timestamp=1_700_000_000,
+        parent_hash=Hash32(bytes.fromhex("aa" * 32)),
+        fee_recipient=Address(bytes.fromhex("bb" * 20)),
+        state_root=Hash32(bytes.fromhex("cc" * 32)),
+        receipts_root=Hash32(bytes.fromhex("dd" * 32)),
+        logs_bloom=Bloom(bytes.fromhex("00" * 256)),
+        prev_randao=Bytes32(bytes.fromhex("ee" * 32)),
+        block_number=uint64(21_000_000),
+        gas_limit=uint64(30_000_000),
+        gas_used=uint64(21_000),
+        timestamp=uint64(1_700_000_000),
         extra_data=bytes.fromhex("dead"),
-        base_fee_per_gas=10**18,
-        block_hash=bytes.fromhex("ff" * 32),
+        base_fee_per_gas=uint256(10**18),
+        block_hash=Hash32(bytes.fromhex("ff" * 32)),
         transactions=list(TRANSACTIONS),
         withdrawals=[_withdrawal()],
-        blob_gas_used=131_072,
-        excess_blob_gas=0,
+        blob_gas_used=uint64(131_072),
+        excess_blob_gas=uint64(0),
         block_access_list=bytes.fromhex("c0de"),
-        slot_number=9_999,
+        slot_number=uint64(9_999),
     )
 
 
 def _max_envelope() -> ExecutionPayloadEnvelopeAmsterdam:
-    """The maximal (Amsterdam) envelope wrapping :func:`_max_payload`."""
+    """A fully-populated envelope wrapping :func:`_random_payload`."""
     return ExecutionPayloadEnvelopeAmsterdam(
-        payload=_max_payload(),
-        parent_beacon_block_root=bytes.fromhex("12" * 32),
+        payload=_random_payload(),
+        parent_beacon_block_root=Root(bytes.fromhex("12" * 32)),
         execution_requests=[bytes.fromhex("00aa"), bytes.fromhex("01bbcc")],
     )
 
@@ -68,7 +71,7 @@ def test_withdrawal_round_trip() -> None:
 
 def test_payload_round_trip() -> None:
     """An execution payload survives encode -> decode unchanged."""
-    value = _max_payload()
+    value = _random_payload()
     raw = encode_bytes(value)
     assert decode_bytes(ExecutionPayloadAmsterdam, raw) == value
 
@@ -93,11 +96,11 @@ def test_transactions_two_level_offsets() -> None:
     Transactions of differing lengths round-trip exactly, and reordering them
     changes the root -- the inner offset table is order- and length-sensitive.
     """
-    value = _max_payload()
+    value = _random_payload()
     decoded = decode_bytes(ExecutionPayloadAmsterdam, encode_bytes(value))
     assert [bytes(tx) for tx in decoded.transactions] == TRANSACTIONS
 
-    reordered = _max_payload()
+    reordered = _random_payload()
     reordered.transactions = list(reversed(TRANSACTIONS))
     assert hash_tree_root(reordered) != hash_tree_root(value)
 

packages/testing/src/execution_testing/ssz/tests/test_engine_containers.py

@@ -10,36 +10,14 @@
     EXECUTION_PAYLOAD_BODY_BY_FORK,
     FORKCHOICE_UPDATE_BY_FORK,
     PAYLOAD_ATTRIBUTES_BY_FORK,
-    BlobAndProofV1,
-    BlobAndProofV2,
-    BlobCellsAndProofs,
-    BlobsBundleV1,
-    BlobsBundleV2,
-    BlobsV1Request,
-    BlobsV1Response,
-    BlobsV4Request,
-    BlobV1Entry,
-    BlobV4Entry,
-    BodiesByHashRequest,
-    BodiesResponse,
-    BodyEntry,
-    CapabilitiesResponse,
-    ClientVersion,
     ExecutionPayloadEnvelopeAmsterdam,
     ExecutionPayloadEnvelopeParis,
-    ForkchoiceState,
-    ForkchoiceUpdateResponse,
-    IdentityResponse,
     PayloadStatus,
 )
 
 _FORKS = ["Paris", "Shanghai", "Cancun", "Prague", "Osaka", "Amsterdam"]
 
 
-def _fields(cls: object) -> list:
-    return list(cls.fields().keys())
-
-
 def test_new_registries_cover_forks_in_order() -> None:
     """Every new per-fork registry spans Paris..Amsterdam."""
     for reg in (
@@ -51,111 +29,6 @@ def test_new_registries_cover_forks_in_order() -> None:
         assert list(reg) == _FORKS
 
 
-def test_payload_attributes_field_deltas() -> None:
-    """PayloadAttributes grows by the fields each fork added."""
-    expected = ["timestamp", "prev_randao", "suggested_fee_recipient"]
-    additions = {
-        "Paris": [],
-        "Shanghai": ["withdrawals"],
-        "Cancun": ["parent_beacon_block_root"],
-        "Prague": [],
-        "Osaka": [],
-        "Amsterdam": ["slot_number", "target_gas_limit"],
-    }
-    for fork, cls in PAYLOAD_ATTRIBUTES_BY_FORK.items():
-        expected = expected + additions[fork]
-        assert _fields(cls) == expected, fork
-
-
-def test_execution_payload_body_field_deltas() -> None:
-    """ExecutionPayloadBody grows transactions -> withdrawals -> BAL."""
-    expected = ["transactions"]
-    additions = {
-        "Paris": [],
-        "Shanghai": ["withdrawals"],
-        "Cancun": [],
-        "Prague": [],
-        "Osaka": [],
-        "Amsterdam": ["block_access_list"],
-    }
-    for fork, cls in EXECUTION_PAYLOAD_BODY_BY_FORK.items():
-        expected = expected + additions[fork]
-        assert _fields(cls) == expected, fork
-
-
-def test_built_payload_field_order() -> None:
-    """
-    BuiltPayload field order per fork.
-    """
-    expected = {
-        "Paris": ["payload", "block_value"],
-        "Shanghai": ["payload", "block_value", "should_override_builder"],
-        "Cancun": [
-            "payload",
-            "block_value",
-            "blobs_bundle",
-            "should_override_builder",
-        ],
-        "Prague": [
-            "payload",
-            "block_value",
-            "blobs_bundle",
-            "execution_requests",
-            "should_override_builder",
-        ],
-    }
-    expected["Osaka"] = expected["Prague"]
-    expected["Amsterdam"] = expected["Prague"]
-    for fork, cls in BUILT_PAYLOAD_BY_FORK.items():
-        assert _fields(cls) == expected[fork], fork
-
-
-def test_forkchoice_update_field_order() -> None:
-    """ForkchoiceUpdate gains custody_columns only at Amsterdam."""
-    for fork, cls in FORKCHOICE_UPDATE_BY_FORK.items():
-        base = ["forkchoice_state", "payload_attributes"]
-        if fork == "Amsterdam":
-            base = base + ["custody_columns"]
-        assert _fields(cls) == base, fork
-
-
-def test_single_container_field_orders() -> None:
-    """Exact field order for the fork-independent containers."""
-    assert _fields(ForkchoiceState) == [
-        "head_block_hash",
-        "safe_block_hash",
-        "finalized_block_hash",
-    ]
-    assert _fields(PayloadStatus) == [
-        "status",
-        "latest_valid_hash",
-        "validation_error",
-    ]
-    assert _fields(ForkchoiceUpdateResponse) == [
-        "payload_status",
-        "payload_id",
-    ]
-    assert _fields(BlobsBundleV1) == ["commitments", "proofs", "blobs"]
-    assert _fields(BlobsBundleV2) == ["commitments", "proofs", "blobs"]
-    assert _fields(BlobAndProofV1) == ["blob", "proof"]
-    assert _fields(BlobAndProofV2) == ["blob", "proofs"]
-    assert _fields(BlobCellsAndProofs) == ["blob_cells", "proofs"]
-    assert _fields(BodiesByHashRequest) == ["block_hashes"]
-    assert _fields(BodyEntry) == ["available", "body"]
-    assert _fields(BodiesResponse) == ["entries"]
-    assert _fields(BlobsV1Request) == ["versioned_hashes"]
-    assert _fields(BlobV1Entry) == ["available", "contents"]
-    assert _fields(BlobsV1Response) == ["entries"]
-    assert _fields(BlobsV4Request) == [
-        "versioned_hashes",
-        "indices_bitarray",
-    ]
-    assert _fields(BlobV4Entry) == ["available", "contents"]
-    assert _fields(ClientVersion) == ["code", "name", "version", "commit"]
-    assert _fields(IdentityResponse) == ["versions"]
-    assert _fields(CapabilitiesResponse) == ["capabilities"]
-
-
 def test_payload_status_optional_encoding_matches_spec_examples() -> None:
     """
     The ``Optional``/``String`` wire shape tests.