generic precompiles with only data parameter

Signed-off-by: Ignacio Hagopian <jsign.uy@gmail.com>

Author: jsign

tests/zkevm/test_worst_compute.py

@@ -11,6 +11,7 @@
 
 from ethereum_test_forks import Fork
 from ethereum_test_tools import (
+    Address,
     Alloc,
     Block,
     BlockchainTestFiller,
@@ -113,6 +114,94 @@ def test_worst_keccak(
     )
 
 
+@pytest.mark.zkevm
+@pytest.mark.valid_from("Cancun")
+@pytest.mark.parametrize(
+    "gas_limit",
+    [
+        Environment().gas_limit,
+    ],
+)
+@pytest.mark.parametrize(
+    "address,static_cost,per_word_dynamic_cost,bytes_per_unit_of_work",
+    [
+        pytest.param(0x02, 60, 12, 64, id="SHA2-256"),
+        pytest.param(0x03, 600, 120, 64, id="RIPEMD-160"),
+        pytest.param(0x04, 15, 3, 1, id="IDENTITY"),
+    ],
+)
+def test_worst_precompile_only_data_input(
+    blockchain_test: BlockchainTestFiller,
+    pre: Alloc,
+    fork: Fork,
+    gas_limit: int,
+    address: Address,
+    static_cost: int,
+    per_word_dynamic_cost: int,
+    bytes_per_unit_of_work: int,
+):
+    """Test running a block with as many precompile calls which have a single `data` input."""
+    env = Environment(gas_limit=gas_limit)
+
+    # Intrinsic gas cost is paid once.
+    intrinsic_gas_calculator = fork.transaction_intrinsic_cost_calculator()
+    available_gas = gas_limit - intrinsic_gas_calculator()
+
+    gsc = fork.gas_costs()
+    mem_exp_gas_calculator = fork.memory_expansion_gas_calculator()
+
+    # Discover the optimal input size to maximize precompile calls, not precompile permutations.
+    max_work = 0
+    optimal_input_length = 0
+    for input_length in range(1, 1_000_000, 32):
+        staticcall_parameters_gas = (
+            gsc.G_BASE  # PUSH0 = arg offset
+            + gsc.G_BASE  # PUSH0 = arg size
+            + gsc.G_BASE  # PUSH0 = arg size
+            + gsc.G_VERY_LOW  # PUSH0 = arg offset
+            + gsc.G_VERY_LOW  # PUSHN = address
+            + gsc.G_BASE  # GAS
+        )
+        iteration_gas_cost = (
+            staticcall_parameters_gas
+            + +static_cost  # Precompile static cost
+            + math.ceil(input_length / 32) * per_word_dynamic_cost  # Precompile dynamic cost
+            + gsc.G_BASE  # POP
+        )
+        # From the available gas, we substract the mem expansion costs considering we know the
+        # current input size length.
+        available_gas_after_expansion = max(
+            0, available_gas - mem_exp_gas_calculator(new_bytes=input_length)
+        )
+        # Calculate how many calls we can do.
+        num_calls = available_gas_after_expansion // iteration_gas_cost
+        total_work = num_calls * math.ceil(input_length / bytes_per_unit_of_work)
+
+        # If we found an input size that is better (reg permutations/gas), then save it.
+        if total_work > max_work:
+            max_work = total_work
+            optimal_input_length = input_length
+
+    calldata = Op.CODECOPY(0, 0, optimal_input_length)
+    attack_block = Op.POP(Op.STATICCALL(Op.GAS, address, 0, optimal_input_length, 0, 0))
+    code = code_loop_precompile_call(calldata, attack_block)
+
+    code_address = pre.deploy_contract(code=code)
+
+    tx = Transaction(
+        to=code_address,
+        gas_limit=gas_limit,
+        sender=pre.fund_eoa(),
+    )
+
+    blockchain_test(
+        env=env,
+        pre=pre,
+        post={},
+        blocks=[Block(txs=[tx])],
+    )
+
+
 @pytest.mark.zkevm
 @pytest.mark.valid_from("Cancun")
 @pytest.mark.parametrize(