fix(tests): Issues with rlp block limit tests and --generate-pre-alloc-groups (#1989)

* refactor: don't hard-code gas limit; pull from env

* bugfix: Use sender fixture for all block calculations

- If a signed transaction has leading zeros in any of the signature fields,
  the rlp encoding will remove those leading zeros. When we swapped the real
  sender in, the signature would change and we could have a variability in the
  block rlp size. So we should use the ``sender`` fixture for the original
  transaction building and pass those original transactions to the final
  block instead of swapping senders (unnecessary).

Author: fselmo

docs/CHANGELOG.md

@@ -142,6 +142,7 @@ Users can select any of the artifacts depending on their testing needs for their
 - ✨ [EIP-7825](https://eips.ethereum.org/EIPS/eip-7825): Pre-Osaka tests have been updated to either (1) dynamically adapt to the transaction gas limit cap, or (2) reduce overall gas consumption to fit the new limit ([#1928](https://github.com/ethereum/EIPs/pull/1928)).
 - ✨ [EIP-7918](https://eips.ethereum.org/EIPS/eip-7918): Blob base fee bounded by execution cost test cases (initial), includes some adjustments to [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) tests ([#1685](https://github.com/ethereum/execution-spec-tests/pull/1685)).
 - 🔀 Adds the max blob transaction limit to the tests including updates to [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) for Osaka ([#1884](https://github.com/ethereum/execution-spec-tests/pull/1884)).
+- 🐞 Fix issues when filling block rlp size limit tests with ``--generate-pre-alloc-groups`` ([#1989](https://github.com/ethereum/execution-spec-tests/pull/1989)).
 
 ## [v4.5.0](https://github.com/ethereum/execution-spec-tests/releases/tag/v4.5.0) - 2025-05-14
 

tests/osaka/eip7934_block_rlp_limit/test_max_block_rlp_size.py

@@ -108,6 +108,7 @@ def exact_size_transactions(
     block_size_limit: int,
     fork: Fork,
     pre: Alloc,
+    gas_limit: int,
     emit_logs: bool = False,
     specific_transaction_to_include: Transaction | None = None,
 ) -> Tuple[List[Transaction], int]:
@@ -122,6 +123,7 @@ def exact_size_transactions(
         block_size_limit: The target block RLP size limit
         fork: The fork to generate transactions for
         pre: Required if emit_logs is True, used to deploy the log contract
+        gas_limit: The gas limit for the block
         emit_logs: If True, transactions will call a contract that emits logs
         specific_transaction_to_include: If provided, this transaction will be included
 
@@ -153,45 +155,53 @@ def exact_size_transactions(
 
     if not specific_transaction_to_include:
         # use cached version when possible for performance
-        stubbed_transactions, gas_used = _exact_size_transactions_cached(
-            block_size_limit, fork, emit_logs_contract=log_contract
+        transactions, gas_used = _exact_size_transactions_cached(
+            block_size_limit,
+            fork,
+            gas_limit,
+            sender,
+            emit_logs_contract=log_contract,
         )
     else:
         # Direct calculation, no cache, since `Transaction` is not hashable
-        stubbed_transactions, gas_used = _exact_size_transactions_impl(
+        transactions, gas_used = _exact_size_transactions_impl(
             block_size_limit,
             fork,
+            gas_limit,
+            sender,
             specific_transaction_to_include=specific_transaction_to_include,
         )
 
-    test_transactions = []
-    for tx in stubbed_transactions:
-        # Create a new transaction with the correct sender, preserving all other fields
-        tx_dict = tx.model_dump(exclude_unset=True)
-        tx_dict.pop("r", None)
-        tx_dict.pop("s", None)
-        tx_dict.pop("v", None)
-        tx_dict["sender"] = sender
-        test_transactions.append(Transaction(**tx_dict))
-    return test_transactions, gas_used
+    return transactions, gas_used
 
 
 @lru_cache(maxsize=128)
 def _exact_size_transactions_cached(
     block_size_limit: int,
     fork: Fork,
+    gas_limit: int,
+    sender: EOA,
     emit_logs_contract: Address | None = None,
 ) -> Tuple[List[Transaction], int]:
     """
     Generate transactions that fill a block to exactly the RLP size limit. Abstracted
     with hashable arguments for caching block calculations.
     """
-    return _exact_size_transactions_impl(block_size_limit, fork, None, emit_logs_contract)
+    return _exact_size_transactions_impl(
+        block_size_limit,
+        fork,
+        gas_limit,
+        sender,
+        None,
+        emit_logs_contract,
+    )
 
 
 def _exact_size_transactions_impl(
     block_size_limit: int,
     fork: Fork,
+    block_gas_limit: int,
+    sender: EOA,
     specific_transaction_to_include: Transaction | None = None,
     emit_logs_contract: Address | None = None,
 ) -> Tuple[List[Transaction], int]:
@@ -200,10 +210,8 @@ def _exact_size_transactions_impl(
     non-cached paths.
     """
     transactions = []
-    sender = EOA("0x" + "00" * 20, key=123)
     nonce = 0
     total_gas_used = 0
-    max_block_gas = 100_000_000
 
     calculator = fork.transaction_intrinsic_cost_calculator()
 
@@ -268,7 +276,7 @@ def _exact_size_transactions_impl(
 
     current_size = get_block_rlp_size(transactions, gas_used=total_gas_used)
     remaining_bytes = block_size_limit - current_size
-    remaining_gas = max_block_gas - total_gas_used
+    remaining_gas = block_gas_limit - total_gas_used
 
     if remaining_bytes > 0 and remaining_gas > 50_000:
         # create an empty transaction to measure base contribution
@@ -360,7 +368,9 @@ def _exact_size_transactions_impl(
     final_gas = sum(tx.gas_limit for tx in transactions)
 
     assert final_size == block_size_limit, (
-        f"Size mismatch: got {final_size}, expected {block_size_limit}"
+        f"Size mismatch: got {final_size}, "
+        f"expected {block_size_limit} "
+        f"({final_size - block_size_limit} bytes diff)"
     )
     return transactions, final_gas
 
@@ -395,6 +405,7 @@ def test_block_at_rlp_size_limit_boundary(
         block_size_limit,
         fork,
         pre,
+        env.gas_limit,
     )
     block_rlp_size = get_block_rlp_size(transactions, gas_used=gas_used)
     assert block_rlp_size == block_size_limit, (
@@ -441,6 +452,7 @@ def test_block_rlp_size_at_limit_with_all_typed_transactions(
         block_size_limit,
         fork,
         pre,
+        env.gas_limit,
         specific_transaction_to_include=typed_transaction,
     )
     block_rlp_size = get_block_rlp_size(transactions, gas_used=gas_used)
@@ -477,6 +489,7 @@ def test_block_at_rlp_limit_with_logs(
         block_size_limit,
         fork,
         pre,
+        env.gas_limit,
         emit_logs=True,
     )