cancun test now uses new Blob class

Author: felix314159

src/ethereum_test_types/__init__.py

@@ -1,11 +1,11 @@
 """Common definitions and types."""
 
+from .blob import Blob
 from .eest_types import (
     EOA,
     Account,
     Alloc,
     AuthorizationTuple,
-    # Blob,
     CamelModel,
     ConsolidationRequest,
     DepositRequest,

src/ethereum_test_types/blob.py

@@ -400,47 +400,47 @@ def corrupt_byte(b: bytes) -> Bytes:
 #         static_blob.write_to_file()
 # --------------------------------------------
 
-myosaka: Fork = Osaka
-myprague: Fork = Prague
-mycancun: Fork = Cancun
-myseed: int = 1337  # fork+seed is the unique ID of a blob
-mytimestamp: int = 168123123
-b: Blob = Blob.NewBlob(myosaka, myseed, mytimestamp)
-json_str: str = b.model_dump_json()
-restored: Blob = Blob.model_validate_json(json_str)
-assert b.data == restored.data
-assert b.commitment == restored.commitment
-assert b.proof == restored.proof
-assert b.cells == restored.cells
-assert b.versioned_hash == restored.versioned_hash
-assert b.name == restored.name
-assert b.fork == restored.fork
-assert b.timestamp == restored.timestamp
-print(type(b.proof), len(b.proof))
-print(BYTES_PER_FIELD_ELEMENT)
-print(len(b.data))
-# b.write_to_file()
-# c: Blob = Blob.LoadBlobFromFile("blob_" + "osaka" + "_" + str(myseed) + "_" + str(mytimestamp))
-# assert b.data == c.data
-# assert b.commitment == c.commitment
-# assert b.proof == c.proof
-# assert b.cells == c.cells
-# assert b.versioned_hash == c.versioned_hash
-# assert b.name == c.name
-# assert b.fork == c.fork
-# assert b.timestamp == c.timestamp
-d: Blob = Blob.NewBlob(myprague, myseed, 123)
-# d.write_to_file()
-e: Blob = Blob.NewBlob(myprague, myseed, 123)
-print("Line above should say blob already existed and was loaded from file")
-ee: Blob = Blob.NewBlob(myprague, myseed, 1234)
-newtimestamp = 999999
-f: Blob = Blob.NewBlob(mycancun, 1337, newtimestamp)
-# f.write_to_file()
-h: Blob = Blob.NewBlob(myosaka, myseed)
-# h.write_to_file()
-zz: Blob = Blob.NewBlob(myosaka, myseed)
-print("Line above should say blob already existed and was loaded from file")
+# myosaka: Fork = Osaka
+# myprague: Fork = Prague
+# mycancun: Fork = Cancun
+# myseed: int = 1337  # fork+seed is the unique ID of a blob
+# mytimestamp: int = 168123123
+# b: Blob = Blob.NewBlob(myosaka, myseed, mytimestamp)
+# json_str: str = b.model_dump_json()
+# restored: Blob = Blob.model_validate_json(json_str)
+# assert b.data == restored.data
+# assert b.commitment == restored.commitment
+# assert b.proof == restored.proof
+# assert b.cells == restored.cells
+# assert b.versioned_hash == restored.versioned_hash
+# assert b.name == restored.name
+# assert b.fork == restored.fork
+# assert b.timestamp == restored.timestamp
+# print(type(b.proof), len(b.proof))
+# print(BYTES_PER_FIELD_ELEMENT)
+# print(len(b.data))
+# # b.write_to_file()
+# # c: Blob = Blob.LoadBlobFromFile("blob_" + "osaka" + "_" + str(myseed) + "_" + str(mytimestamp))
+# # assert b.data == c.data
+# # assert b.commitment == c.commitment
+# # assert b.proof == c.proof
+# # assert b.cells == c.cells
+# # assert b.versioned_hash == c.versioned_hash
+# # assert b.name == c.name
+# # assert b.fork == c.fork
+# # assert b.timestamp == c.timestamp
+# d: Blob = Blob.NewBlob(myprague, myseed, 123)
+# # d.write_to_file()
+# e: Blob = Blob.NewBlob(myprague, myseed, 123)
+# print("Line above should say blob already existed and was loaded from file")
+# ee: Blob = Blob.NewBlob(myprague, myseed, 1234)
+# newtimestamp = 999999
+# f: Blob = Blob.NewBlob(mycancun, 1337, newtimestamp)
+# # f.write_to_file()
+# h: Blob = Blob.NewBlob(myosaka, myseed)
+# # h.write_to_file()
+# zz: Blob = Blob.NewBlob(myosaka, myseed)
+# print("Line above should say blob already existed and was loaded from file")
 # you can load a blob either via just filename or via absolute path or via relative path (cwd is ./src/ethereum_test_types)  # noqa: E501
 # yyy: Blob = Blob.LoadBlobFromFile("blob_cancun_1337_999999.json")
 # # yyyy: Blob = Blob.LoadBlobFromFile(
@@ -456,16 +456,16 @@ def corrupt_byte(b: bytes) -> Bytes:
 
 # test proof corruption
 #   osaka
-testseed = 55
-ddd: Blob = Blob.NewBlob(Osaka, testseed + 10)
-oldValue = ddd.proof[0][5]
-for m in Blob.ProofCorruptionMode:
-    ddd.corrupt_proof(m)
-print("proof corruption works (osaka):", oldValue != ddd.proof[0][5])
-#   prague
-eeeeeeeeee: Blob = Blob.NewBlob(Prague, testseed + 11)
-oldValue = eeeeeeeeee.proof[5]
-for m in Blob.ProofCorruptionMode:
-    eeeeeeeeee.corrupt_proof(m)
-print("proof corruption works (prague):", oldValue != eeeeeeeeee.proof[5])
-print("pydantic model works")
+# testseed = 55
+# ddd: Blob = Blob.NewBlob(Osaka, testseed + 10)
+# oldValue = ddd.proof[0][5]
+# for m in Blob.ProofCorruptionMode:
+#     ddd.corrupt_proof(m)
+# print("proof corruption works (osaka):", oldValue != ddd.proof[0][5])
+# #   prague
+# eeeeeeeeee: Blob = Blob.NewBlob(Prague, testseed + 11)
+# oldValue = eeeeeeeeee.proof[5]
+# for m in Blob.ProofCorruptionMode:
+#     eeeeeeeeee.corrupt_proof(m)
+# print("proof corruption works (prague):", oldValue != eeeeeeeeee.proof[5])
+# print("pydantic model works")

tests/cancun/eip4844_blobs/common.py

@@ -1,42 +1,30 @@
 """Common constants, classes & functions local to EIP-4844 tests."""
 
-from dataclasses import dataclass
 from typing import List, Literal, Tuple
 
-from .spec import Spec
+from ethereum_test_types.blob import Blob
+
+from .spec import Spec, ref_spec_4844
 
 INF_POINT = (0xC0 << 376).to_bytes(48, byteorder="big")
 Z = 0x623CE31CF9759A5C8DAF3A357992F9F3DD7F9339D8998BC8E68373E54F00B75E
 Z_Y_INVALID_ENDIANNESS: Literal["little", "big"] = "little"
 Z_Y_VALID_ENDIANNESS: Literal["little", "big"] = "big"
 
 
-@dataclass(kw_only=True)
-class Blob:
-    """Class representing a full blob."""
-
-    blob: bytes
-    kzg_commitment: bytes
-    kzg_proof: bytes
-
-    def versioned_hash(self) -> bytes:
-        """Calculate versioned hash for a given blob."""
-        return Spec.kzg_to_versioned_hash(self.kzg_commitment)
-
-    @staticmethod
-    def blobs_to_transaction_input(
-        input_blobs: List["Blob"],
-    ) -> Tuple[List[bytes], List[bytes], List[bytes]]:
-        """
-        Return tuple of lists of blobs, kzg commitments formatted to be added to a network blob
-        type transaction.
-        """
-        blobs: List[bytes] = []
-        kzg_commitments: List[bytes] = []
-        kzg_proofs: List[bytes] = []
-
-        for blob in input_blobs:
-            blobs.append(blob.blob)
-            kzg_commitments.append(blob.kzg_commitment)
-            kzg_proofs.append(blob.kzg_proof)
-        return (blobs, kzg_commitments, kzg_proofs)
+def blobs_to_transaction_input(
+    input_blobs: List[Blob],
+) -> Tuple[List[bytes], List[bytes], List[bytes]]:
+    """
+    Return tuple of lists of blobs, kzg commitments formatted to be added to a network blob
+    type transaction.
+    """
+    blobs: List[bytes] = []
+    kzg_commitments: List[bytes] = []
+    kzg_proofs: List[bytes] = []
+
+    for blob in input_blobs:
+        blobs.append(blob.data)
+        kzg_commitments.append(blob.commitment)
+        kzg_proofs.append(blob.proof)
+    return (blobs, kzg_commitments, kzg_proofs)

tests/cancun/eip4844_blobs/test_blob_txs_full.py

@@ -8,6 +8,7 @@
 
 import pytest
 
+from ethereum_test_base_types.base_types import Hash
 from ethereum_test_forks import Fork
 from ethereum_test_tools import (
     Address,
@@ -21,9 +22,10 @@
     Transaction,
     TransactionException,
 )
+from ethereum_test_types import Blob
+from tests.cancun.eip4844_blobs.common import blobs_to_transaction_input
 
-from .common import INF_POINT, Blob
-from .spec import Spec, SpecHelpers, ref_spec_4844
+from .spec import Spec, ref_spec_4844
 
 REFERENCE_SPEC_GIT_PATH = ref_spec_4844.git_path
 REFERENCE_SPEC_VERSION = ref_spec_4844.version
@@ -92,7 +94,11 @@ def tx_max_priority_fee_per_gas() -> int:
 @pytest.fixture
 def txs_versioned_hashes(txs_blobs: List[List[Blob]]) -> List[List[bytes]]:
     """List of blob versioned hashes derived from the blobs."""
-    return [[blob.versioned_hash() for blob in blob_tx] for blob_tx in txs_blobs]
+    version_hashes: List[List[Hash]] = [
+        [blob.versioned_hash for blob in blob_tx] for blob_tx in txs_blobs
+    ]
+    # TODO: how to convert Hash to bytes?
+    return version_hashes
 
 
 @pytest.fixture(autouse=True)
@@ -178,7 +184,7 @@ def txs(  # noqa: D103
             wrapped_blob_transaction=tx_wrapped_blobs,
         )
         if tx_wrapped_blobs:
-            blobs_info = Blob.blobs_to_transaction_input(tx_blobs)
+            blobs_info = blobs_to_transaction_input(tx_blobs)
             network_wrapped_tx = NetworkWrappedTransaction(
                 tx=tx,
                 blobs=blobs_info[0],
@@ -242,17 +248,12 @@ def generate_full_blob_tests(
     Return a list of tests for invalid blob transactions due to insufficient max fee per blob gas
     parametrized for each different fork.
     """
-    blob_size = Spec.FIELD_ELEMENTS_PER_BLOB * SpecHelpers.BYTES_PER_FIELD_ELEMENT
     max_blobs = fork.max_blobs_per_block()
     return [
         pytest.param(
             [  # Txs
                 [  # Blobs per transaction
-                    Blob(
-                        blob=bytes(blob_size),
-                        kzg_commitment=INF_POINT,
-                        kzg_proof=INF_POINT,
-                    ),
+                    Blob.NewBlob(fork),
                 ]
             ],
             [True],
@@ -261,11 +262,7 @@ def generate_full_blob_tests(
         pytest.param(
             [  # Txs
                 [  # Blobs per transaction
-                    Blob(
-                        blob=bytes(blob_size),
-                        kzg_commitment=INF_POINT,
-                        kzg_proof=INF_POINT,
-                    )
+                    Blob.NewBlob(fork),
                 ]
                 for _ in range(max_blobs)
             ],
@@ -275,11 +272,7 @@ def generate_full_blob_tests(
         pytest.param(
             [  # Txs
                 [  # Blobs per transaction
-                    Blob(
-                        blob=bytes(blob_size),
-                        kzg_commitment=INF_POINT,
-                        kzg_proof=INF_POINT,
-                    )
+                    Blob.NewBlob(fork),
                 ]
                 for _ in range(max_blobs)
             ],