implemented feedback

Author: felix314159

src/ethereum_test_base_types/conversions.py

@@ -55,7 +55,7 @@ def to_bytes(input_bytes: BytesConvertible) -> bytes:
     # handle wrapper_version field for >= osaka
     if isinstance(input_bytes, int):
         assert input_bytes < 256, f"Expected int that fits into one byte, but got {input_bytes}"
-        return input_bytes.to_bytes(1, "big")
+        return input_bytes.to_bytes(1, byteorder="big")
 
     logger.error(
         f"This type of input_bytes is not yet supported: {type(input_bytes)}\n\n"

src/ethereum_test_rpc/rpc.py

@@ -137,7 +137,7 @@ def post_request(self, method: str, *params: Any, extra_headers: Dict | None = N
         payload_size_bytes = len(payload_json.encode("utf-8"))
         payload_size_mb = payload_size_bytes / (1024 * 1024)
         logger.debug(
-            f"I am about to send a POST request of approximated size: {payload_size_mb:.2f} MB "
+            f"POST request of approximated size: {payload_size_mb:.2f} MB "
             f"({payload_size_bytes} bytes)"
         )
 

src/ethereum_test_types/blob_types.py

@@ -9,11 +9,10 @@
 
 import ckzg  # type: ignore
 import platformdirs
-from pydantic import field_serializer, field_validator
 
 from ethereum_test_base_types.base_types import Bytes, Hash
 from ethereum_test_base_types.pydantic import CamelModel
-from ethereum_test_forks import Cancun, Fork, Osaka, Prague
+from ethereum_test_forks import Fork
 from pytest_plugins.logging import get_logger
 
 CACHED_BLOBS_DIRECTORY: Path = (
@@ -29,27 +28,14 @@ def clear_blob_cache(cached_blobs_folder_path: Path):
     for f in cached_blobs_folder_path.glob("*.json"):  # only delete .json files
         try:
             f.unlink()  # permanently delete this file
-        except OSError as e:
+        except Exception as e:
             print(
                 f"Critical error while trying to delete file {f}:{e}.. "
                 "Aborting clearing of blob cache folder."
             )
             return
 
 
-def fork_string_to_object(fork_name: str) -> type[Cancun] | type[Prague] | type[Osaka]:
-    """Take a fork string and return the respective fork as object."""
-    fork_name = fork_name.lower()
-
-    if fork_name == "cancun":
-        return Cancun
-    if fork_name == "prague":
-        return Prague
-    if fork_name == "osaka":
-        return Osaka
-    raise ValueError(f"Fork {fork_name} has not yet been implemented in this function.")
-
-
 class Blob(CamelModel):
     """Class representing a full blob."""
 
@@ -72,29 +58,8 @@ def trusted_setup(cls):
         if cls._trusted_setup is None:
             trusted_setup_path = Path(realpath(__file__)).parent / "kzg_trusted_setup.txt"
             trusted_setup = ckzg.load_trusted_setup(str(trusted_setup_path), 0)
-            print(f"{trusted_setup_path} has been loaded")
             cls._trusted_setup = trusted_setup
-
-    @field_validator("fork", mode="before")
-    @classmethod
-    def validate_fork(cls, v):
-        """
-        When reading JSON file and trying to go back from fork string to fork object we must
-        tell pydantic how to do this.
-        """
-        if isinstance(v, str):
-            fork_object = fork_string_to_object(v)
-            cls.fork = fork_object
-            return fork_object
-        return v
-
-    @field_serializer("fork")
-    def serialize_fork(self, fork: Fork) -> str:
-        """
-        When trying to serialize a Blob object into a JSON file we must
-        tell pydantic how to do this.
-        """
-        return fork.name()
+            print("I HAVE LOADED THE TRUSTED SETUP")
 
     @staticmethod
     def get_filename(fork: Fork, seed: int) -> str:
@@ -108,12 +73,6 @@ def get_filepath(fork: Fork, seed: int):
         # determine amount of cell proofs for this fork (0 or 128)
         would_be_filename: str = Blob.get_filename(fork, seed)
 
-        # create cached blobs dir if necessary
-        if not CACHED_BLOBS_DIRECTORY.exists():
-            CACHED_BLOBS_DIRECTORY.mkdir(
-                parents=True, exist_ok=True
-            )  # create all necessary dirs on the way
-
         # return path to blob
         return CACHED_BLOBS_DIRECTORY / would_be_filename
 
@@ -162,7 +121,7 @@ def get_commitment(data: Bytes) -> Bytes:
             )
 
             # calculate commitment
-            commitment = ckzg.blob_to_kzg_commitment(data, Blob._trusted_setup)
+            commitment = ckzg.blob_to_kzg_commitment(data, Blob.trusted_setup())
             assert len(commitment) == fork.get_blob_constant("BYTES_PER_COMMITMENT"), (
                 f"Expected {fork.get_blob_constant('BYTES_PER_COMMITMENT')} "
                 f"resulting commitments but got {len(commitment)} commitments"
@@ -215,7 +174,13 @@ def get_cells(fork: Fork, data: Bytes) -> List[Bytes] | None:
                 f"cell proofs {amount_cell_proofs} but expected 128."
             )
 
-        # first, handle transition forks
+        # first, create cached blobs dir if necessary
+        if not CACHED_BLOBS_DIRECTORY.exists():
+            CACHED_BLOBS_DIRECTORY.mkdir(
+                parents=True, exist_ok=True
+            )  # create all necessary dirs on the way
+
+        # handle transition forks
         # (blob related constants are needed and only available for normal forks)
         fork = fork.fork_at(timestamp=timestamp)
 
@@ -238,7 +203,7 @@ def get_cells(fork: Fork, data: Bytes) -> List[Bytes] | None:
         versioned_hash: Hash = get_versioned_hash(commitment)
         name: str = Blob.get_filename(fork, seed)
 
-        return Blob(
+        blob = Blob(
             data=data,
             commitment=commitment,
             proof=proof,
@@ -249,6 +214,10 @@ def get_cells(fork: Fork, data: Bytes) -> List[Bytes] | None:
             seed=seed,
             timestamp=timestamp,
         )
+        # for most effective caching temporarily persist every blob that is created in cache
+        blob.write_to_file()
+
+        return blob
 
     @staticmethod
     def from_file(file_name: str) -> "Blob":

src/ethereum_test_types/tests/test_blob_types.py

@@ -1,9 +1,7 @@
 """Test suite for blobs."""
 
 import copy
-from pathlib import Path
 
-import platformdirs
 import pytest
 
 from ethereum_test_forks import (
@@ -17,11 +15,7 @@
     ShanghaiToCancunAtTime15k,
 )
 
-from ..blob_types import Blob, clear_blob_cache
-
-CACHED_BLOBS_DIRECTORY: Path = (
-    Path(platformdirs.user_cache_dir("ethereum-execution-spec-tests")) / "cached_blobs"
-)
+from ..blob_types import CACHED_BLOBS_DIRECTORY, Blob, clear_blob_cache
 
 
 @pytest.mark.parametrize("seed", [0, 10, 100])
@@ -46,15 +40,7 @@ def test_blob_creation_and_writing_and_reading(
     restored = Blob.from_file(file_name)
 
     # ensure file you read equals file you wrote
-    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.seed == restored.seed
-    assert b.timestamp == restored.timestamp
+    assert b.model_dump() == restored.model_dump()
 
 
 @pytest.mark.parametrize(

src/ethereum_test_types/transaction_types.py

@@ -730,22 +730,6 @@ def get_rlp_fields(self) -> List[str]:
         if self.cell_proofs is not None:
             rlp_cell_proofs = ["cell_proofs"]
 
-        # Geth expects:
-        #   type blobTxWithBlobs struct {
-        #       BlobTx      *BlobTx
-        #       Blobs       []kzg4844.Blob
-        #       Commitments []kzg4844.Commitment
-        #       Proofs      []kzg4844.Proof
-        #   }
-
-        #   type versionedBlobTxWithBlobs struct {
-        #       BlobTx      *BlobTx
-        #       Version     byte
-        #       Blobs       []kzg4844.Blob
-        #       Commitments []kzg4844.Commitment
-        #       Proofs      []kzg4844.Proof
-        #   }
-
         rlp_fields: List[
             str
         ] = [  # structure explained in https://eips.ethereum.org/EIPS/eip-7594#Networking
@@ -761,7 +745,7 @@ def get_rlp_fields(self) -> List[str]:
             "Neither proofs nor cell_proofs are in rlp_fields. Critical error!"
         )
 
-        logger.debug(f"Ended up with this rlp field list: {rlp_fields}")
+        # logger.debug(f"Ended up with this rlp field list: {rlp_fields}")
 
         return rlp_fields
 

tests/cancun/eip4844_blobs/test_blob_txs_full.py

@@ -254,19 +254,19 @@ def generate_full_blob_tests(
         pytest.param(
             [  # Txs
                 [  # Blobs per transaction
-                    Blob.from_fork(fork),
+                    Blob.from_fork(fork, s),
                 ]
-                for _ in range(max_blobs)
+                for s in range(max_blobs)
             ],
             [True] + ([False] * (max_blobs - 1)),
             id="one_full_blob_max_txs",
         ),
         pytest.param(
             [  # Txs
                 [  # Blobs per transaction
-                    Blob.from_fork(fork),
+                    Blob.from_fork(fork, s),
                 ]
-                for _ in range(max_blobs)
+                for s in range(max_blobs)
             ],
             ([False] * (max_blobs - 1)) + [True],
             id="one_full_blob_at_the_end_max_txs",

tests/osaka/eip7594_peerdas/test_get_blobs.py

@@ -222,17 +222,17 @@ def generate_full_blob_tests(
         pytest.param(
             [  # Txs
                 [  # Blobs per transaction
-                    Blob.from_fork(fork) for _ in range(max_blobs)
+                    Blob.from_fork(fork, s) for s in range(max_blobs)
                 ]
             ],
             id="max_blobs_transaction",
         ),
         pytest.param(
             [  # Txs
                 [  # Blobs per transaction
-                    Blob.from_fork(fork),
+                    Blob.from_fork(fork, s),
                 ]
-                for _ in range(max_blobs)
+                for s in range(max_blobs)
             ],
             id="single_blob_max_txs",
         ),