✨ feat(gentest): Support for transaction types (#1166)

* ✨ feat(gentest): Type 2 transaction

* ✨ feat: Source of truth for Tx model

* 🥢 nit: Casting to tx

* gentest: src/cli/gentest/tests/test_cli.py refactor

* fix(rpc): Adapt client's response to our model

* fix(rpc): More fixes

* fix(rpc): Use pydantic's AliasChoice

---------

Co-authored-by: raxhvl <[email protected]>
Co-authored-by: Mario Vega <[email protected]>

Author: raxhvl

src/cli/gentest/request_manager.py

@@ -12,32 +12,16 @@
 
 from typing import Dict
 
-from pydantic import BaseModel
-
 from config import EnvConfig
-from ethereum_test_base_types import Hash, HexNumber
+from ethereum_test_base_types import Hash
 from ethereum_test_rpc import BlockNumberType, DebugRPC, EthRPC
-from ethereum_test_types import Transaction
+from ethereum_test_rpc.types import TransactionByHashResponse
+from ethereum_test_types import Environment
 
 
 class RPCRequest:
     """Interface for the RPC interaction with remote node."""
 
-    class RemoteTransaction(Transaction):
-        """Model that represents a transaction."""
-
-        block_number: HexNumber
-        tx_hash: Hash
-
-    class RemoteBlock(BaseModel):
-        """Model that represents a block."""
-
-        coinbase: str
-        difficulty: str
-        gas_limit: str
-        number: str
-        timestamp: str
-
     node_url: str
     headers: dict[str, str]
 
@@ -49,46 +33,27 @@ def __init__(self):
         self.rpc = EthRPC(node_config.node_url, extra_headers=headers)
         self.debug_rpc = DebugRPC(node_config.node_url, extra_headers=headers)
 
-    def eth_get_transaction_by_hash(self, transaction_hash: Hash) -> RemoteTransaction:
+    def eth_get_transaction_by_hash(self, transaction_hash: Hash) -> TransactionByHashResponse:
         """Get transaction data."""
         res = self.rpc.get_transaction_by_hash(transaction_hash)
         block_number = res.block_number
         assert block_number is not None, "Transaction does not seem to be included in any block"
 
-        assert res.ty == 0, (
-            f"Transaction has type {res.ty}: Currently only type 0 transactions are supported."
-        )
-
-        return RPCRequest.RemoteTransaction(
-            block_number=block_number,
-            tx_hash=res.transaction_hash,
-            ty=res.ty,
-            gas_limit=res.gas_limit,
-            gas_price=res.gas_price,
-            data=res.data,
-            nonce=res.nonce,
-            sender=res.from_address,
-            to=res.to_address,
-            value=res.value,
-            v=res.v,
-            r=res.r,
-            s=res.s,
-            protected=True if res.v > 30 else False,
-        )
+        return res
 
-    def eth_get_block_by_number(self, block_number: BlockNumberType) -> RemoteBlock:
+    def eth_get_block_by_number(self, block_number: BlockNumberType) -> Environment:
         """Get block by number."""
         res = self.rpc.get_block_by_number(block_number)
 
-        return RPCRequest.RemoteBlock(
-            coinbase=res["miner"],
+        return Environment(
+            fee_recipient=res["miner"],
             number=res["number"],
             difficulty=res["difficulty"],
             gas_limit=res["gasLimit"],
             timestamp=res["timestamp"],
         )
 
-    def debug_trace_call(self, transaction: RemoteTransaction) -> Dict[str, dict]:
+    def debug_trace_call(self, transaction: TransactionByHashResponse) -> Dict[str, dict]:
         """Get pre-state required for transaction."""
         assert transaction.sender is not None
         assert transaction.to is not None

src/cli/gentest/test_context_providers.py

@@ -38,8 +38,8 @@ class StateTestProvider(Provider):
     """Provides context required to generate a `state_test` using pytest."""
 
     transaction_hash: Hash
-    block: Optional[RPCRequest.RemoteBlock] = None
-    transaction: Optional[RPCRequest.RemoteTransaction] = None
+    block: Optional[Environment] = None
+    transaction: Optional[Transaction] = None
     state: Optional[Dict[str, Dict]] = None
 
     def _make_rpc_calls(self):
@@ -60,7 +60,7 @@ def _make_rpc_calls(self):
 
     def _get_environment(self) -> Environment:
         assert self.block is not None
-        return Environment(**self.block.model_dump())
+        return self.block
 
     def _get_pre_state(self) -> Dict[str, Account]:
         assert self.state is not None
@@ -79,7 +79,7 @@ def _get_pre_state(self) -> Dict[str, Account]:
 
     def _get_transaction(self) -> Transaction:
         assert self.transaction is not None
-        return Transaction(**self.transaction.model_dump())
+        return self.transaction
 
     def get_context(self) -> Dict[str, Any]:
         """

src/cli/gentest/test_providers.py

@@ -17,15 +17,15 @@
 from pydantic import BaseModel
 
 from ethereum_test_base_types import Account, Address, ZeroPaddedHexNumber
-
-from .request_manager import RPCRequest
+from ethereum_test_rpc.types import TransactionByHashResponse
+from ethereum_test_types import Environment
 
 
 class BlockchainTestProvider(BaseModel):
     """Provides context required to generate a `blockchain_test` using pytest."""
 
-    block: RPCRequest.RemoteBlock
-    transaction: RPCRequest.RemoteTransaction
+    block: Environment
+    transaction: TransactionByHashResponse
     state: Dict[Address, Account]
 
     def _get_environment_kwargs(self) -> str:
@@ -111,5 +111,5 @@ def get_context(self) -> Dict[str, Any]:
             "environment_kwargs": self._get_environment_kwargs(),
             "pre_state_items": self._get_pre_state_items(),
             "transaction_items": self._get_transaction_items(),
-            "tx_hash": self.transaction.tx_hash,
+            "tx_hash": self.transaction.hash,
         }

src/cli/gentest/tests/test_cli.py

@@ -1,5 +1,6 @@
 """Tests for the gentest CLI command."""
 
+import pytest
 from click.testing import CliRunner
 
 from cli.gentest.cli import generate
@@ -8,91 +9,104 @@
 from ethereum_test_base_types import Account
 from ethereum_test_tools import Environment, Storage, Transaction
 
+transactions_by_type = {
+    0: {
+        "environment": Environment(
+            fee_recipient="0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            gas_limit=9916577,
+            number=9974504,
+            timestamp=1588257377,
+            difficulty=2315196811272822,
+            parent_ommers_hash="0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+            extra_data=b"\x00",
+        ),
+        "pre_state": {
+            "0x5a0b54d5dc17e0aadc383d2db43b0a0d3e029c4c": Account(
+                nonce=6038603, balance=23760714652307793035, code=b"", storage=Storage(root={})
+            ),
+            "0x8a4a4d396a06cba2a7a4a73245991de40cdec289": Account(
+                nonce=2, balance=816540000000000000, code=b"", storage=Storage(root={})
+            ),
+            "0xc6d96786477f82491bfead8f00b8294688f77abc": Account(
+                nonce=25, balance=29020266497911578313, code=b"", storage=Storage(root={})
+            ),
+        },
+        "transaction": Transaction(
+            ty=0,
+            chain_id=1,
+            nonce=2,
+            gas_price=10000000000,
+            gas_limit=21000,
+            to="0xc6d96786477f82491bfead8f00b8294688f77abc",
+            value=668250000000000000,
+            data=b"",
+            v=38,
+            r=57233334052658009540326312124836763247359579695589124499839562829147086216092,
+            s=49687643984819828983661675232336138386174947240467726918882054280625462464348,
+            sender="0x8a4a4d396a06cba2a7a4a73245991de40cdec289",
+        ),
+    },
+    2: {
+        "environment": Environment(
+            fee_recipient="0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            gas_limit=30172625,
+            number=21758000,
+            timestamp=1738489319,
+            parent_ommers_hash="0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+            extra_data=b"\x00",
+        ),
+        "pre_state": {
+            "0x24d6c74d811cfde65995ed26fd08af445f8aab06": Account(
+                nonce=1011, balance=139840767390685635650, code=b"", storage=Storage(root={})
+            ),
+            "0xd5fbda4c79f38920159fe5f22df9655fde292d47": Account(
+                nonce=553563, balance=162510989019530720334, code=b"", storage=Storage(root={})
+            ),
+            "0xe2e29f9a85cfecb9cdaa83a81c7aa2792f24d93f": Account(
+                nonce=104, balance=553317651330968100, code=b"", storage=Storage(root={})
+            ),
+        },
+        "transaction": Transaction(
+            ty=2,
+            chain_id=1,
+            nonce=553563,
+            max_priority_fee_per_gas=1900000,
+            max_fee_per_gas=3992652948,
+            gas_limit=63000,
+            to="0xe2e29f9a85cfecb9cdaa83a81c7aa2792f24d93f",
+            value=221305417266040400,
+            v=1,
+            r=23565967349511399087318407428036702220029523660288023156323795583373026415631,
+            s=9175853102116430015855393834807954374677057556696757715994220939907579927771,
+            sender="0xd5fbda4c79f38920159fe5f22df9655fde292d47",
+        ),
+    },
+}
 
-def test_generate_success(tmp_path, monkeypatch):
-    """Test the generate command with a successful scenario."""
-    ## Arrange ##
 
+@pytest.fixture
+def transaction_hash(tx_type: int) -> str:  # noqa: D103
+    return str(transactions_by_type[tx_type]["transaction"].hash)  # type: ignore
+
+
+@pytest.mark.parametrize("tx_type", list(transactions_by_type.keys()))
+def test_tx_type(tmp_path, monkeypatch, tx_type, transaction_hash):
+    """Generates a test case for any transaction type."""
+    ## Arrange ##
     # This test is run in a CI environment, where connection to a node could be
     # unreliable. Therefore, we mock the RPC request to avoid any network issues.
     # This is done by patching the `get_context` method of the `StateTestProvider`.
     runner = CliRunner()
-    transaction_hash = "0xa41f343be7a150b740e5c939fa4d89f3a2850dbe21715df96b612fc20d1906be"
-    output_file = str(tmp_path / "gentest.py")
+    output_file = str(tmp_path / f"gentest_type_{tx_type}.py")
+
+    tx = transactions_by_type[tx_type]
 
     def get_mock_context(self: StateTestProvider) -> dict:
-        return {
-            "environment": Environment(
-                fee_recipient="0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
-                gas_limit=9916577,
-                number=9974504,
-                timestamp=1588257377,
-                prev_randao=None,
-                difficulty=2315196811272822,
-                base_fee_per_gas=None,
-                excess_blob_gas=None,
-                target_blobs_per_block=None,
-                parent_difficulty=None,
-                parent_timestamp=None,
-                parent_base_fee_per_gas=None,
-                parent_gas_used=None,
-                parent_gas_limit=None,
-                blob_gas_used=None,
-                parent_ommers_hash="0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-                parent_blob_gas_used=None,
-                parent_excess_blob_gas=None,
-                parent_beacon_block_root=None,
-                block_hashes={},
-                ommers=[],
-                withdrawals=None,
-                extra_data=b"\x00",
-                parent_hash=None,
-            ),
-            "pre_state": {
-                "0x5a0b54d5dc17e0aadc383d2db43b0a0d3e029c4c": Account(
-                    nonce=6038603, balance=23760714652307793035, code=b"", storage=Storage(root={})
-                ),
-                "0x8a4a4d396a06cba2a7a4a73245991de40cdec289": Account(
-                    nonce=2, balance=816540000000000000, code=b"", storage=Storage(root={})
-                ),
-                "0xc6d96786477f82491bfead8f00b8294688f77abc": Account(
-                    nonce=25, balance=29020266497911578313, code=b"", storage=Storage(root={})
-                ),
-            },
-            "transaction": Transaction(
-                ty=0,
-                chain_id=1,
-                nonce=2,
-                gas_price=10000000000,
-                max_priority_fee_per_gas=None,
-                max_fee_per_gas=None,
-                gas_limit=21000,
-                to="0xc6d96786477f82491bfead8f00b8294688f77abc",
-                value=668250000000000000,
-                data=b"",
-                access_list=None,
-                max_fee_per_blob_gas=None,
-                blob_versioned_hashes=None,
-                v=38,
-                r=57233334052658009540326312124836763247359579695589124499839562829147086216092,
-                s=49687643984819828983661675232336138386174947240467726918882054280625462464348,
-                sender="0x8a4a4d396a06cba2a7a4a73245991de40cdec289",
-                authorization_list=None,
-                secret_key=None,
-                error=None,
-                protected=True,
-                rlp_override=None,
-                wrapped_blob_transaction=False,
-                blobs=None,
-                blob_kzg_commitments=None,
-                blob_kzg_proofs=None,
-            ),
-            "tx_hash": transaction_hash,
-        }
+        return tx
 
     monkeypatch.setattr(StateTestProvider, "get_context", get_mock_context)
 
-    ## Genenrate ##
+    ## Generate ##
     gentest_result = runner.invoke(generate, [transaction_hash, output_file])
     assert gentest_result.exit_code == 0
 

src/config/env.py

@@ -68,7 +68,7 @@ def __init__(self):
         if not ENV_PATH.exists():
             raise FileNotFoundError(
                 f"The configuration file '{ENV_PATH}' does not exist. "
-                "Run `uv run env_int` to create it."
+                "Run `uv run eest make env` to create it."
             )
 
         with ENV_PATH.open("r") as file: