wip fixing execute with actual blobs

Author: felix314159

src/ethereum_test_base_types/conversions.py

@@ -7,6 +7,10 @@
 FixedSizeBytesConvertible: TypeAlias = str | bytes | SupportsBytes | List[int] | int
 NumberConvertible: TypeAlias = str | bytes | SupportsBytes | int
 
+from pytest_plugins.logging import get_logger
+
+logger = get_logger(__name__)
+
 
 def int_or_none(input_value: Any, default: Optional[int] = None) -> int | None:
     """Convert a value to int or returns a default (None)."""
@@ -47,6 +51,16 @@ def to_bytes(input_bytes: BytesConvertible) -> bytes:
             input_bytes = "0" + input_bytes
         return bytes.fromhex(input_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")
+
+    logger.error(
+        f"This type of input_bytes is not yet supported: {type(input_bytes)}\n\n"
+        f"input_bytes: {input_bytes}"
+    )
+
     raise Exception("invalid type for `bytes`")
 
 

src/ethereum_test_execution/blob_transaction.py

@@ -19,7 +19,7 @@ def versioned_hashes_with_blobs_and_proofs(
     proofs.
     """
     versioned_hashes: Dict[Hash, BlobAndProofV1 | BlobAndProofV2] = {}
-    for blob in tx.blobs:
+    for blob in tx.blob_objects:
         if isinstance(blob.proof, Bytes):
             versioned_hashes[blob.versioned_hash] = BlobAndProofV1(
                 blob=blob.data, proof=blob.proof

src/ethereum_test_types/transaction_types.py

@@ -652,58 +652,54 @@ class NetworkWrappedTransaction(CamelModel, RLPSerializable):
     """
     Network wrapped transaction as defined in
     [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844#networking).
-    """
-
-    tx: Transaction
-    wrapper_version: Union[Bytes | None] = None
-    blobs: Sequence[Blob]
 
-    @computed_field  # type: ignore[prop-decorator]
-    @property
-    def blob_wrapper_version(self) -> bytes | None:
-        """Return the wrapper version (byte 1 for Osaka, None pre-Osaka)."""
-        # TODO: it could be a mix of blobs from different forks, then what would be the wrapper version?
-        if len(self.blobs) == 0:
-            return None
+    < Osaka:
+        rlp([tx_payload_body,                   blobs, commitments, proofs])
 
-        fork = self.blobs[0].fork
-        amount_cell_proofs = fork.get_blob_constant("AMOUNT_CELL_PROOFS")
-        assert isinstance(amount_cell_proofs, int), (
-            f"Expected AMOUNT_CELL_PROOFS of fork {fork} to be an int but this is not the case!"
-        )
-        if amount_cell_proofs > 0:
-            return bytes([1])
+    >= Osaka:
+        rlp([tx_payload_body, wrapper_version,  blobs, commitments, cell_proofs])
+    """
 
-        return None
+    tx: Transaction
+    blob_objects: Sequence[Blob]
+    wrapper_version: Union[Bytes | None] = None  # only exists in >= osaka
 
     @computed_field  # type: ignore[prop-decorator]
     @property
-    def blob_data(self) -> Sequence[Bytes]:
-        """Return a list of blobs as bytes."""
-        return [blob.data for blob in self.blobs]
+    def blobs(self) -> Sequence[Bytes]:
+        """Return a list of blob data as bytes."""
+        return [blob.data for blob in self.blob_objects]
 
     @computed_field  # type: ignore[prop-decorator]
     @property
-    def blob_kzg_commitments(self) -> Sequence[Bytes]:
+    def commitments(self) -> Sequence[Bytes]:
         """Return a list of kzg commitments."""
-        return [blob.commitment for blob in self.blobs]
+        return [blob.commitment for blob in self.blob_objects]
 
     @computed_field  # type: ignore[prop-decorator]
     @property
-    def blob_kzg_proofs(self) -> Sequence[Bytes | Sequence[Bytes]]:
-        """Return a list of kzg proofs."""
-        proofs: list[Bytes | list[Bytes]] = []
-        for blob in self.blobs:
+    def proofs(self) -> Sequence[Bytes] | None:
+        """Return a list of kzg proofs (returns None >= Osaka)."""
+        if self.wrapper_version is not None:
+            return None
+
+        proofs: list[Bytes] = []
+        for blob in self.blob_objects:
+            assert isinstance(blob.proof, Bytes)
             proofs.append(blob.proof)
 
         return proofs
 
     @computed_field  # type: ignore[prop-decorator]
     @property
-    def blob_cells(self) -> Sequence[Sequence[Bytes] | None]:
-        """Return a list of cells."""
-        cells: list[list[Bytes] | None] = []
-        for blob in self.blobs:
+    def cell_proofs(self) -> Sequence[Sequence[Bytes]] | None:
+        """Return a list of cells (returns None < Osaka)."""
+        if self.wrapper_version is None:
+            return None
+
+        cells: list[list[Bytes]] = []
+        for blob in self.blob_objects:
+            assert isinstance(blob.cells, list)
             cells.append(blob.cells)
 
         return cells
@@ -718,13 +714,26 @@ def get_rlp_fields(self) -> List[str]:
 
         The list can be nested list up to one extra level to represent nested fields.
         """
+        # only put a wrapper_version field for >=osaka (value 1), otherwise omit field
+        wrapper = []
+        if self.wrapper_version is not None:
+            wrapper = ["wrapper_version"]
+
+        proofs: list[str] = []
+        if len(proofs) > 0:
+            proofs = ["proofs"]
+
+        cell_proofs: list[str] = []
+        if len(cell_proofs) > 0:
+            cell_proofs = ["cell_proofs"]
+
         return [  # structure explained in https://eips.ethereum.org/EIPS/eip-7594#Networking
             "tx",  # tx_payload_body
-            "blob_wrapper_version",  # wrapper_version, which is always 1 for osaka (was it non-existing before?)
-            "blob_data",  # blobs
-            "blob_kzg_commitments",  # commitments
-            "blob_kzg_proofs",  # cell_proofs
-            "blob_cells",
+            *wrapper,  # wrapper_version, which is always 1 for osaka (was non-existing before)
+            "blobs",  # Blob.data
+            "commitments",
+            *proofs,  # only included < osaka
+            *cell_proofs,  # only included >= osaka
         ]
 
     def get_rlp_prefix(self) -> bytes:

tests/cancun/eip4844_blobs/test_blob_txs_full.py

@@ -182,7 +182,7 @@ def txs(  # noqa: D103
             wrapped_blob_transaction=tx_wrapped_blobs,
         )
         if tx_wrapped_blobs:
-            network_wrapped_tx = NetworkWrappedTransaction(tx=tx, blobs=tx_blobs)
+            network_wrapped_tx = NetworkWrappedTransaction(tx=tx, blob_objects=tx_blobs)
             tx.rlp_override = network_wrapped_tx.rlp()
         txs.append(tx)
     return txs

tests/osaka/eip7594_peerdas/test_get_blobs.py

@@ -182,8 +182,8 @@ def txs(  # noqa: D103
         )
         network_wrapped_tx = NetworkWrappedTransaction(
             tx=tx,
-            blobs=tx_blobs,
             wrapper_version=tx_wrapper_version,
+            blob_objects=tx_blobs,
         )
         txs.append(network_wrapped_tx)
     return txs