refactor(tests): EIP-7623: Add gas-used check to tests

Author: marioevz

tests/prague/eip7623_increase_calldata_cost/conftest.py

@@ -16,9 +16,11 @@
     Hash,
     Transaction,
     TransactionException,
+    add_kzg_version,
 )
 from ethereum_test_tools import Opcodes as Op
 
+from ...cancun.eip4844_blobs.spec import Spec as EIP_4844_Spec
 from .helpers import DataTestType, find_floor_cost_threshold
 
 
@@ -65,7 +67,7 @@ def access_list() -> List[AccessList] | None:
 
 
 @pytest.fixture
-def authorization_existing_authority() -> bool:
+def authorization_refund() -> bool:
     """Return whether the transaction has an existing authority in the authorization list."""
     return False
 
@@ -74,7 +76,7 @@ def authorization_existing_authority() -> bool:
 def authorization_list(
     request: pytest.FixtureRequest,
     pre: Alloc,
-    authorization_existing_authority: bool,
+    authorization_refund: bool,
 ) -> List[AuthorizationTuple] | None:
     """
     Authorization-list for the transaction.
@@ -88,17 +90,22 @@ def authorization_list(
     if request.param is None:
         return None
     return [
-        AuthorizationTuple(
-            signer=pre.fund_eoa(1 if authorization_existing_authority else 0), address=address
-        )
+        AuthorizationTuple(signer=pre.fund_eoa(1 if authorization_refund else 0), address=address)
         for address in request.param
     ]
 
 
 @pytest.fixture
-def blob_versioned_hashes() -> Sequence[Hash] | None:
+def blob_versioned_hashes(ty: int) -> Sequence[Hash] | None:
     """Versioned hashes for the transaction."""
-    return None
+    return (
+        add_kzg_version(
+            [Hash(1)],
+            EIP_4844_Spec.BLOB_COMMITMENT_VERSION_KZG,
+        )
+        if ty == 3
+        else None
+    )
 
 
 @pytest.fixture
@@ -224,34 +231,51 @@ def tx_gas_delta() -> int:
 
 
 @pytest.fixture
-def tx_gas(
+def tx_intrinsic_gas_cost(
     fork: Fork,
     tx_data: Bytes,
     access_list: List[AccessList] | None,
     authorization_list: List[AuthorizationTuple] | None,
     contract_creating_tx: bool,
-    tx_gas_delta: int,
 ) -> int:
     """
-    Gas limit for the transaction.
+    Transaction intrinsic gas cost.
 
     The calculated value takes into account the normal intrinsic gas cost and the floor data gas
     cost.
-
-    The gas delta is added to the intrinsic gas cost to generate different test scenarios.
     """
     intrinsic_gas_cost_calculator = fork.transaction_intrinsic_cost_calculator()
-    return (
-        intrinsic_gas_cost_calculator(
-            calldata=tx_data,
-            contract_creation=contract_creating_tx,
-            access_list=access_list,
-            authorization_list_or_count=authorization_list,
-        )
-        + tx_gas_delta
+    return intrinsic_gas_cost_calculator(
+        calldata=tx_data,
+        contract_creation=contract_creating_tx,
+        access_list=access_list,
+        authorization_list_or_count=authorization_list,
     )
 
 
+@pytest.fixture
+def tx_floor_data_cost(
+    fork: Fork,
+    tx_data: Bytes,
+) -> int:
+    """Floor data cost for the given transaction data."""
+    fork_data_floor_cost_calculator = fork.transaction_data_floor_cost_calculator()
+    return fork_data_floor_cost_calculator(data=tx_data)
+
+
+@pytest.fixture
+def tx_gas_limit(
+    tx_intrinsic_gas_cost: int,
+    tx_gas_delta: int,
+) -> int:
+    """
+    Gas limit for the transaction.
+
+    The gas delta is added to the intrinsic gas cost to generate different test scenarios.
+    """
+    return tx_intrinsic_gas_cost + tx_gas_delta
+
+
 @pytest.fixture
 def tx_error(tx_gas_delta: int) -> TransactionException | None:
     """Transaction error, only expected if the gas delta is negative."""
@@ -268,7 +292,7 @@ def tx(
     access_list: List[AccessList] | None,
     authorization_list: List[AuthorizationTuple] | None,
     blob_versioned_hashes: Sequence[Hash] | None,
-    tx_gas: int,
+    tx_gas_limit: int,
     tx_error: TransactionException | None,
 ) -> Transaction:
     """Create the transaction used in each test."""
@@ -280,7 +304,7 @@ def tx(
         protected=protected,
         access_list=access_list,
         authorization_list=authorization_list,
-        gas_limit=tx_gas,
+        gas_limit=tx_gas_limit,
         blob_versioned_hashes=blob_versioned_hashes,
         error=tx_error,
     )

tests/prague/eip7623_increase_calldata_cost/test_execution_gas.py

@@ -14,14 +14,12 @@
     Alloc,
     AuthorizationTuple,
     Bytes,
-    Hash,
     StateTestFiller,
     Transaction,
-    add_kzg_version,
+    TransactionReceipt,
 )
 from ethereum_test_tools import Opcodes as Op
 
-from ...cancun.eip4844_blobs.spec import Spec as EIP_4844_Spec
 from .helpers import DataTestType
 from .spec import ref_spec_7623
 
@@ -39,7 +37,7 @@ def data_test_type() -> DataTestType:
 
 
 @pytest.fixture
-def authorization_existing_authority() -> bool:
+def authorization_refund() -> bool:
     """
     Force the authority of the authorization tuple to be an existing authority in order
     to produce a refund.
@@ -68,27 +66,31 @@ def to(
         """Return a contract that when executed results in refunds due to storage clearing."""
         return pre.deploy_contract(Op.SSTORE(0, 0) + Op.STOP, storage={0: 1})
 
+    @pytest.fixture
+    def refund(self, fork: Fork, ty: int) -> int:
+        """Return the refund gas of the transaction."""
+        gas_costs = fork.gas_costs()
+        refund = gas_costs.R_STORAGE_CLEAR
+        if ty == 4:
+            refund += gas_costs.R_AUTHORIZATION_EXISTING_AUTHORITY
+        return refund
+
     @pytest.mark.parametrize(
-        "ty,protected,blob_versioned_hashes,authorization_list",
+        "ty,protected,authorization_list",
         [
-            pytest.param(0, False, None, None, id="type_0_unprotected"),
-            pytest.param(0, True, None, None, id="type_0_protected"),
-            pytest.param(1, True, None, None, id="type_1"),
-            pytest.param(2, True, None, None, id="type_2"),
+            pytest.param(0, False, None, id="type_0_unprotected"),
+            pytest.param(0, True, None, id="type_0_protected"),
+            pytest.param(1, True, None, id="type_1"),
+            pytest.param(2, True, None, id="type_2"),
             pytest.param(
                 3,
                 True,
-                add_kzg_version(
-                    [Hash(1)],
-                    EIP_4844_Spec.BLOB_COMMITMENT_VERSION_KZG,
-                ),
                 None,
                 id="type_3",
             ),
             pytest.param(
                 4,
                 True,
-                None,
                 [Address(1)],
                 id="type_4_with_authorization_refund",
             ),
@@ -109,13 +111,16 @@ def test_gas_refunds_from_data_floor(
         state_test: StateTestFiller,
         pre: Alloc,
         tx: Transaction,
+        tx_floor_data_cost: int,
+        refund: int,
     ) -> None:
         """
         Test gas refunds deducted from the data floor.
 
         I.e. the used gas by the intrinsic gas cost plus the execution cost is less than the data
         floor, hence data floor is used, and then the gas refunds are applied to the data floor.
         """
+        tx.expected_receipt = TransactionReceipt(gas_used=tx_floor_data_cost - refund)
         state_test(
             pre=pre,
             post={
@@ -143,27 +148,36 @@ def to(
         """Return a contract that consumes all gas when executed by calling an invalid opcode."""
         return pre.deploy_contract(Op.INVALID)
 
+    @pytest.fixture
+    def refund(
+        self,
+        fork: Fork,
+        ty: int,
+        authorization_refund: bool,
+    ) -> int:
+        """Return the refund gas of the transaction."""
+        gas_costs = fork.gas_costs()
+        refund = 0
+        if ty == 4 and authorization_refund:
+            refund += gas_costs.R_AUTHORIZATION_EXISTING_AUTHORITY
+        return refund
+
     @pytest.mark.parametrize(
-        "ty,protected,blob_versioned_hashes,authorization_list",
+        "ty,protected,authorization_list",
         [
-            pytest.param(0, False, None, None, id="type_0_unprotected"),
-            pytest.param(0, True, None, None, id="type_0_protected"),
-            pytest.param(1, True, None, None, id="type_1"),
-            pytest.param(2, True, None, None, id="type_2"),
+            pytest.param(0, False, None, id="type_0_unprotected"),
+            pytest.param(0, True, None, id="type_0_protected"),
+            pytest.param(1, True, None, id="type_1"),
+            pytest.param(2, True, None, id="type_2"),
             pytest.param(
                 3,
                 True,
-                add_kzg_version(
-                    [Hash(1)],
-                    EIP_4844_Spec.BLOB_COMMITMENT_VERSION_KZG,
-                ),
                 None,
                 id="type_3",
             ),
             pytest.param(
                 4,
                 True,
-                None,
                 [Address(1)],
                 id="type_4_with_authorization_refund",
             ),
@@ -184,8 +198,10 @@ def test_full_gas_consumption(
         state_test: StateTestFiller,
         pre: Alloc,
         tx: Transaction,
+        refund: int,
     ) -> None:
         """Test executing a transaction that fully consumes its execution gas allocation."""
+        tx.expected_receipt = TransactionReceipt(gas_used=tx.gas_limit - refund)
         state_test(
             pre=pre,
             post={},
@@ -201,6 +217,20 @@ def contract_creating_tx(self) -> bool:
         """Use a constant in order to avoid circular fixture dependencies."""
         return False
 
+    @pytest.fixture
+    def refund(
+        self,
+        fork: Fork,
+        ty: int,
+        authorization_refund: bool,
+    ) -> int:
+        """Return the refund gas of the transaction."""
+        gas_costs = fork.gas_costs()
+        refund = 0
+        if ty == 4 and authorization_refund:
+            refund += gas_costs.R_AUTHORIZATION_EXISTING_AUTHORITY
+        return refund
+
     @pytest.fixture
     def to(
         self,
@@ -209,19 +239,14 @@ def to(
         tx_data: Bytes,
         access_list: List[AccessList] | None,
         authorization_list: List[AuthorizationTuple] | None,
+        tx_floor_data_cost: int,
     ) -> Address | None:
         """
         Return a contract that consumes almost all the gas before reaching the
         floor data cost.
         """
         intrinsic_gas_cost_calculator = fork.transaction_intrinsic_cost_calculator()
-        data_floor = intrinsic_gas_cost_calculator(
-            calldata=tx_data,
-            contract_creation=False,
-            access_list=access_list,
-            authorization_list_or_count=authorization_list,
-        )
-        execution_gas = data_floor - intrinsic_gas_cost_calculator(
+        execution_gas = tx_floor_data_cost - intrinsic_gas_cost_calculator(
             calldata=tx_data,
             contract_creation=False,
             access_list=access_list,
@@ -233,35 +258,29 @@ def to(
         return pre.deploy_contract((Op.JUMPDEST * (execution_gas - 1)) + Op.STOP)
 
     @pytest.mark.parametrize(
-        "ty,protected,blob_versioned_hashes,authorization_list,authorization_existing_authority",
+        "ty,protected,authorization_list,authorization_refund",
         [
-            pytest.param(0, False, None, None, False, id="type_0_unprotected"),
-            pytest.param(0, True, None, None, False, id="type_0_protected"),
-            pytest.param(1, True, None, None, False, id="type_1"),
-            pytest.param(2, True, None, None, False, id="type_2"),
+            pytest.param(0, False, None, False, id="type_0_unprotected"),
+            pytest.param(0, True, None, False, id="type_0_protected"),
+            pytest.param(1, True, None, False, id="type_1"),
+            pytest.param(2, True, None, False, id="type_2"),
             pytest.param(
                 3,
                 True,
-                add_kzg_version(
-                    [Hash(1)],
-                    EIP_4844_Spec.BLOB_COMMITMENT_VERSION_KZG,
-                ),
                 None,
                 False,
                 id="type_3",
             ),
             pytest.param(
                 4,
                 True,
-                None,
                 [Address(1)],
                 False,
                 id="type_4",
             ),
             pytest.param(
                 4,
                 True,
-                None,
                 [Address(1)],
                 True,
                 id="type_4_with_authorization_refund",
@@ -282,8 +301,11 @@ def test_gas_consumption_below_data_floor(
         state_test: StateTestFiller,
         pre: Alloc,
         tx: Transaction,
+        tx_floor_data_cost: int,
+        refund: int,
     ) -> None:
         """Test executing a transaction that almost consumes the floor data cost."""
+        tx.expected_receipt = TransactionReceipt(gas_used=tx_floor_data_cost - refund)
         state_test(
             pre=pre,
             post={},