fix(execute): add gas validation for benchmark tests in execute mode

Previously, execute mode was not validating that transactions consumed
the expected amount of gas when expected_benchmark_gas_used was set.
This could cause benchmark tests to incorrectly pass even when consuming
significantly less gas than expected (e.g., due to missing factory contracts).
This feature is needed by benchmark tests like the ones in #2186 in
order to make sure that the benchmarks are indeed consuming all gas
available or causing a failure otherwise when the flag is set.

Changes:
- Add expected_benchmark_gas_used and skip_gas_used_validation fields to TransactionPost
- Implement gas validation logic in TransactionPost.execute() using transaction receipts
- Pass gas validation parameters from StateTest and BlockchainTest to TransactionPost
- Add eth_getTransactionReceipt RPC method to fetch gas used from receipts

This ensures benchmark tests fail appropriately when gas consumption doesn't match
expectations, preventing false positives in performance testing.

Author: CPerezz

src/ethereum_test_execution/transaction_post.py

@@ -20,6 +20,10 @@ class TransactionPost(BaseExecute):
 
     blocks: List[List[Transaction]]
     post: Alloc
+    # Gas validation fields for benchmark tests
+    gas_benchmark_value: int | None = None  # Default expected gas from command-line
+    expected_benchmark_gas_used: int | None = None  # Expected total gas to be consumed
+    skip_gas_used_validation: bool = False  # Skip gas validation even if expected is set
 
     format_name: ClassVar[str] = "transaction_post_test"
     description: ClassVar[str] = (
@@ -33,6 +37,10 @@ def execute(
         assert not any(tx.ty == 3 for block in self.blocks for tx in block), (
             "Transaction type 3 is not supported in execute mode."
         )
+
+        # Track transaction hashes for gas validation (benchmarking)
+        all_tx_hashes = []
+
         for block in self.blocks:
             signed_txs = []
             for tx_index, tx in enumerate(block):
@@ -51,11 +59,38 @@ def execute(
                 for transaction in signed_txs:
                     if transaction.error is None:
                         eth_rpc.send_wait_transaction(transaction)
+                        all_tx_hashes.append(transaction.hash)
                     else:
                         with pytest.raises(SendTransactionExceptionError):
                             eth_rpc.send_transaction(transaction)
             else:
                 eth_rpc.send_wait_transactions(signed_txs)
+                all_tx_hashes.extend([tx.hash for tx in signed_txs])
+
+        # Perform gas validation if required for benchmarking
+        # Ensures benchmark tests consume exactly the expected gas
+        if not self.skip_gas_used_validation:
+            # Use expected_benchmark_gas_used if set, else gas_benchmark_value
+            expected_gas = self.expected_benchmark_gas_used
+            if expected_gas is None:
+                expected_gas = self.gas_benchmark_value
+
+            # Only validate if we have an expected value
+            if expected_gas is not None:
+                total_gas_used = 0
+                # Fetch transaction receipts to get actual gas used
+                for tx_hash in all_tx_hashes:
+                    receipt = eth_rpc.get_transaction_receipt(tx_hash)
+                    assert receipt is not None, f"Failed to get receipt for transaction {tx_hash}"
+                    gas_used = int(receipt["gasUsed"], 16)
+                    total_gas_used += gas_used
+
+                # Verify that the total gas consumed matches expectations
+                assert total_gas_used == expected_gas, (
+                    f"Total gas used ({total_gas_used}) does not match "
+                    f"expected gas ({expected_gas}), "
+                    f"difference: {total_gas_used - expected_gas}"
+                )
 
         for address, account in self.post.root.items():
             balance = eth_rpc.get_balance(address)

src/ethereum_test_rpc/rpc.py

@@ -292,6 +292,18 @@ def get_transaction_by_hash(self, transaction_hash: Hash) -> TransactionByHashRe
             pprint(e.errors())
             raise e
 
+    def get_transaction_receipt(self, transaction_hash: Hash) -> dict | None:
+        """
+        `eth_getTransactionReceipt`: Returns transaction receipt.
+
+        Used to get the actual gas used by a transaction for gas validation
+        in benchmark tests.
+        """
+        response = self.post_request(
+            method="getTransactionReceipt", params=[f"{transaction_hash}"]
+        )
+        return response
+
     def get_storage_at(
         self, address: Address, position: Hash, block_number: BlockNumberType = "latest"
     ) -> Hash:

src/ethereum_test_specs/base.py

@@ -76,6 +76,7 @@ class BaseTest(BaseModel):
     _gas_optimization: int | None = PrivateAttr(None)
     _gas_optimization_max_gas_limit: int | None = PrivateAttr(None)
 
+    gas_benchmark_value: int | None = None
     expected_benchmark_gas_used: int | None = None
     skip_gas_used_validation: bool = False
 
@@ -124,6 +125,7 @@ def from_test(
         new_instance = cls(
             tag=base_test.tag,
             t8n_dump_dir=base_test.t8n_dump_dir,
+            gas_benchmark_value=base_test.gas_benchmark_value,
             expected_benchmark_gas_used=base_test.expected_benchmark_gas_used,
             skip_gas_used_validation=base_test.skip_gas_used_validation,
             **kwargs,

src/ethereum_test_specs/blockchain.py

@@ -899,9 +899,13 @@ def execute(
             blocks: List[List[Transaction]] = []
             for block in self.blocks:
                 blocks += [block.txs]
+            # Pass gas validation params for benchmark tests
             return TransactionPost(
                 blocks=blocks,
                 post=self.post,
+                gas_benchmark_value=self.gas_benchmark_value,
+                expected_benchmark_gas_used=self.expected_benchmark_gas_used,
+                skip_gas_used_validation=self.skip_gas_used_validation,
             )
         raise Exception(f"Unsupported execute format: {execute_format}")
 

src/ethereum_test_specs/state.py

@@ -444,9 +444,13 @@ def execute(
     ) -> BaseExecute:
         """Generate the list of test fixtures."""
         if execute_format == TransactionPost:
+            # Pass gas validation params for benchmark tests
             return TransactionPost(
                 blocks=[[self.tx]],
                 post=self.post,
+                gas_benchmark_value=self.gas_benchmark_value,
+                expected_benchmark_gas_used=self.expected_benchmark_gas_used,
+                skip_gas_used_validation=self.skip_gas_used_validation,
             )
         raise Exception(f"Unsupported execute format: {execute_format}")
 

src/pytest_plugins/execute/execute.py

@@ -342,6 +342,9 @@ def __init__(self, *args, **kwargs):
                     kwargs["pre"] = pre
                 elif kwargs["pre"] != pre:
                     raise ValueError("The pre-alloc object was modified by the test.")
+                # Pass gas_benchmark_value if not already set
+                if "gas_benchmark_value" not in kwargs:
+                    kwargs["gas_benchmark_value"] = request.getfixturevalue("gas_benchmark_value")
                 kwargs |= {
                     p: request.getfixturevalue(p)
                     for p in cls_fixture_parameters