feat: label eip checklist and add new cases

Author: LouisTsai-Csie

tests/osaka/eip7825_transaction_gas_limit_cap/test_tx_gas_limit.py

@@ -16,6 +16,7 @@
     AuthorizationTuple,
     Block,
     BlockchainTestFiller,
+    Bytecode,
     Environment,
     Hash,
     StateTestFiller,
@@ -201,6 +202,68 @@ def test_tx_gas_larger_than_block_gas_limit(
     blockchain_test(pre=pre, post={}, blocks=[block])
 
 
+@pytest.mark.parametrize(
+    "exceed_gas_refund_limit",
+    [
+        pytest.param(True),
+        pytest.param(False),
+    ],
+)
+@pytest.mark.valid_from("Osaka")
+def test_maximum_gas_refund(
+    state_test: StateTestFiller,
+    pre: Alloc,
+    fork: Fork,
+    exceed_gas_refund_limit: bool,
+):
+    """Test the maximum gas refund behavior according to EIP-3529."""
+    gas_costs = fork.gas_costs()
+    tx_gas_limit_cap = fork.transaction_gas_limit_cap()
+    assert tx_gas_limit_cap is not None, "Fork does not have a transaction gas limit cap"
+    max_refund_quotient = fork.max_refund_quotient()
+
+    storage = Storage()
+
+    # Base Operation: SSTORE(slot, 0)
+    iteration_cost = gas_costs.G_STORAGE_RESET + gas_costs.G_BASE + gas_costs.G_VERY_LOW
+    gas_refund = gas_costs.R_STORAGE_CLEAR
+
+    # EIP-3529: Reduction in refunds
+    storage_count = tx_gas_limit_cap // iteration_cost
+    gas_used = storage_count * iteration_cost
+
+    maximum_gas_refund = gas_used // max_refund_quotient
+    gas_refund_count = maximum_gas_refund // gas_refund
+
+    # Base case: operations that fit within the refund limit
+    iteraction_count = min(storage_count, gas_refund_count + int(exceed_gas_refund_limit))
+
+    assert iteration_cost * iteraction_count <= tx_gas_limit_cap, (
+        "Iteration cost exceeds tx gas limit cap"
+    )
+
+    opcode = sum(
+        (Op.SSTORE(storage.store_next(0), Op.PUSH0) for _ in range(iteraction_count)),
+        Bytecode(),
+    )
+    assert len(opcode) <= fork.max_code_size(), "code size exceeds max code size"
+
+    contract = pre.deploy_contract(
+        code=opcode,
+        storage={Hash(i): Hash(1) for i in range(iteraction_count)},
+    )
+
+    tx = Transaction(
+        to=contract,
+        sender=pre.fund_eoa(),
+        gas_limit=tx_gas_limit_cap,
+    )
+
+    post = {contract: Account(storage=storage)}
+
+    state_test(pre=pre, post=post, tx=tx)
+
+
 @pytest.fixture
 def total_cost_floor_per_token(fork: Fork):
     """Total cost floor per token."""

tests/osaka/eip7825_transaction_gas_limit_cap/test_tx_gas_limit_transition_fork.py

@@ -5,6 +5,7 @@
 
 import pytest
 
+from ethereum_test_checklists import EIPChecklist
 from ethereum_test_forks import Fork
 from ethereum_test_tools import (
     Account,
@@ -22,6 +23,10 @@
 REFERENCE_SPEC_VERSION = ref_spec_7825.version
 
 
+@EIPChecklist.ModifiedTransactionValidityConstraint.Test.ForkTransition.AcceptedBeforeFork()
+@EIPChecklist.ModifiedTransactionValidityConstraint.Test.ForkTransition.RejectedBeforeFork()
+@EIPChecklist.ModifiedTransactionValidityConstraint.Test.ForkTransition.AcceptedAfterFork()
+@EIPChecklist.ModifiedTransactionValidityConstraint.Test.ForkTransition.RejectedAfterFork()
 @pytest.mark.valid_at_transition_to("Osaka", subsequent_forks=True)
 @pytest.mark.exception_test
 def test_transaction_gas_limit_cap_at_transition(
@@ -35,12 +40,11 @@ def test_transaction_gas_limit_cap_at_transition(
     Before timestamp 15000: No gas limit cap (transactions with gas > 2^24 are valid)
     At/after timestamp 15000: Gas limit cap of 2^24 is enforced
     """
-    sender = pre.fund_eoa()
     contract_address = pre.deploy_contract(
-        code=Op.SSTORE(0, Op.ADD(Op.SLOAD(0), 1)) + Op.STOP,
+        code=Op.SSTORE(Op.TIMESTAMP, Op.ADD(Op.SLOAD(0), 1)) + Op.STOP,
     )
 
-    pre_cap = fork.transaction_gas_limit_cap()
+    pre_cap = fork.transaction_gas_limit_cap(timestamp=14_999)
     post_cap = fork.transaction_gas_limit_cap(timestamp=15_000)
     assert post_cap is not None, "Post cap should not be None"
 
@@ -50,44 +54,57 @@ def test_transaction_gas_limit_cap_at_transition(
         "Post cap should be less than or equal to pre cap, test needs update"
     )
 
-    # Transaction with gas limit above the cap before transition
-    high_gas_tx = Transaction(
+    # Before fork activation
+    high_gas_tx_before_fork = Transaction(
         ty=0,  # Legacy transaction
         to=contract_address,
         gas_limit=pre_cap,
-        data=b"",
-        value=0,
-        sender=sender,
+        sender=pre.fund_eoa(),
+    )
+
+    cap_tx_before_fork = Transaction(
+        ty=0,  # Legacy transaction
+        to=contract_address,
+        gas_limit=post_cap,
+        sender=pre.fund_eoa(),
     )
 
     post_cap_tx_error = TransactionException.GAS_LIMIT_EXCEEDS_MAXIMUM
 
-    # Transaction with gas limit at the cap
-    cap_gas_tx = Transaction(
+    # After fork activation
+    high_gas_tx_after_fork = Transaction(
         ty=0,  # Legacy transaction
         to=contract_address,
-        gas_limit=post_cap + 1,
-        data=b"",
-        value=0,
-        sender=sender,
+        gas_limit=pre_cap,
+        sender=pre.fund_eoa(),
         error=post_cap_tx_error,
     )
 
+    cap_tx_after_fork = Transaction(
+        ty=0,  # Legacy transaction
+        to=contract_address,
+        gas_limit=post_cap,
+        sender=pre.fund_eoa(),
+    )
+
     blocks = []
 
     # Before transition (timestamp < 15000): high gas transaction should succeed
     blocks.append(
         Block(
             timestamp=14_999,
-            txs=[high_gas_tx],
+            txs=[high_gas_tx_before_fork, cap_tx_before_fork],
         )
     )
 
     # At transition (timestamp = 15000): high gas transaction should fail
     blocks.append(
         Block(
             timestamp=15_000,
-            txs=[cap_gas_tx],  # Only transaction at the cap succeeds
+            txs=[
+                cap_tx_after_fork,
+                high_gas_tx_after_fork,
+            ],
             exception=post_cap_tx_error,
         )
     )
@@ -96,7 +113,8 @@ def test_transaction_gas_limit_cap_at_transition(
     post = {
         contract_address: Account(
             storage={
-                0: 1,  # Set by first transaction (before transition)
+                14_999: 1,  # Set by first transaction (before transition)
+                15_000: 0,  # Set by second transaction (at transition)
             }
         )
     }