fix(tests/benchmark): Max size contract deployment execution (#2149)

* fix(tests/benchmark): Max size contract deployment execution

* fix

* fix(test-fill): cache address, don't re-calculate every time; very expensive

---------

Co-authored-by: fselmo <fselmo2@gmail.com>

Author: marioevz

packages/testing/src/execution_testing/tools/tools_code/generators.py

@@ -1,7 +1,7 @@
 """Code generating classes and functions."""
 
 from dataclasses import dataclass
-from typing import Any, Generator, List, Self, SupportsBytes, Tuple, Type
+from typing import Any, Dict, Generator, List, Self, SupportsBytes, Tuple, Type
 
 from pydantic import Field
 
@@ -807,6 +807,16 @@ def tx_iterations_by_gas_limit(
             remaining_gas -= best_iterations_gas
             start_iteration += best_iterations
 
+    def _intrinsic_cost_is_constant(
+        self,
+        intrinsic_cost_kwargs: Dict[str, Any],
+    ) -> bool:
+        """If none of the kwarg values is callable, return True."""
+        for _, value in intrinsic_cost_kwargs.items():
+            if callable(value):
+                return False
+        return True
+
     def tx_iterations_by_total_iteration_count(
         self,
         *,
@@ -828,14 +838,19 @@ def tx_iterations_by_total_iteration_count(
             yield total_iterations
             return
         remaining_iterations = total_iterations
+        best_iterations: int | None = None
+        constant_intrinsic_gas_cost = self._intrinsic_cost_is_constant(
+            intrinsic_cost_kwargs
+        )
 
         while remaining_iterations > 0:
-            best_iterations, _ = self._binary_search_iterations(
-                fork=fork,
-                gas_limit=gas_limit_cap,
-                start_iteration=start_iteration,
-                **intrinsic_cost_kwargs,
-            )
+            if best_iterations is None or not constant_intrinsic_gas_cost:
+                best_iterations, _ = self._binary_search_iterations(
+                    fork=fork,
+                    gas_limit=gas_limit_cap,
+                    start_iteration=start_iteration,
+                    **intrinsic_cost_kwargs,
+                )
             if best_iterations >= remaining_iterations:
                 yield remaining_iterations
                 return

tests/benchmark/compute/helpers.py

@@ -227,6 +227,9 @@ class MaxSizedContractInitcode(FixedIterationsBytecode):
     fork's limits.
     """
 
+    _cached_address: Address
+    """Cached address to avoid expensive recomputation."""
+
     def __new__(cls, *, pre: Alloc, fork: Fork) -> Self:
         """
         Create a new MaxSizedContractInitcode instance.
@@ -292,19 +295,21 @@ def __new__(cls, *, pre: Alloc, fork: Fork) -> Self:
             cleanup=cleanup,
             iteration_count=iteration_count,
         )
+        # Cache the address to avoid expensive recomputation
+        instance._cached_address = compute_deterministic_create2_address(
+            salt=0,
+            initcode=Initcode(deploy_code=instance),
+            fork=fork,
+        )
         deployed_address = pre.deterministic_deploy_contract(
             deploy_code=instance
         )
-        assert deployed_address == instance.address(fork=fork)
+        assert deployed_address == instance._cached_address
         return instance
 
-    def address(self, *, fork: Fork) -> Address:
+    def address(self) -> Address:
         """Get the deterministic address of the initcode."""
-        return compute_deterministic_create2_address(
-            salt=0,
-            initcode=Initcode(deploy_code=self),
-            fork=fork,
-        )
+        return self._cached_address
 
 
 class MaxSizedContractFactory(IteratingBytecode):
@@ -322,6 +327,9 @@ class MaxSizedContractFactory(IteratingBytecode):
     initcode: MaxSizedContractInitcode
     """The initcode used to deploy maximum-sized contracts via CREATE2."""
 
+    _cached_address: Address
+    """Cached address to avoid expensive recomputation."""
+
     def __new__(cls, *, pre: Alloc, fork: Fork) -> Self:
         """
         Create a new MaxSizedContractFactory instance.
@@ -337,7 +345,7 @@ def __new__(cls, *, pre: Alloc, fork: Fork) -> Self:
 
         """
         initcode = MaxSizedContractInitcode(pre=pre, fork=fork)
-        initcode_address = initcode.address(fork=fork)
+        initcode_address = initcode.address()
         setup = (
             Op.EXTCODECOPY(
                 address=initcode_address,
@@ -381,10 +389,16 @@ def __new__(cls, *, pre: Alloc, fork: Fork) -> Self:
             cleanup=cleanup,
         )
         instance.initcode = initcode
+        # Cache the address to avoid expensive recomputation
+        instance._cached_address = compute_deterministic_create2_address(
+            salt=0,
+            initcode=Initcode(deploy_code=instance),
+            fork=fork,
+        )
         deployed_address = pre.deterministic_deploy_contract(
             deploy_code=instance
         )
-        assert deployed_address == instance.address(fork=fork)
+        assert deployed_address == instance._cached_address
         return instance
 
     def transactions_by_total_contract_count(
@@ -400,33 +414,64 @@ def transactions_by_total_contract_count(
         given number of contracts, each capped tx properly capped by the
         gas limit cap of the fork.
         """
-        to = self.address(fork=fork)
+        to = self.address()
+
+        # Use a sensible hardcoded maximum for the calldata, to avoid
+        # binary searching.
+        max_number = (2 ** (contract_count.bit_length() + 1)) - 1
+        calldata_max = Hash(max_number) + Hash(max_number)
 
         def calldata(iteration_count: int, start_iteration: int) -> bytes:
             index_end = iteration_count + start_iteration - 1
             return Hash(start_iteration) + Hash(index_end)
 
-        yield from self.transactions_by_total_iteration_count(
+        start_iteration: int = contract_start_index
+
+        tx_gas_limit: int | None = None
+        tx_gas_cost: int | None = None
+        last_iteration_count: int = 0
+
+        for iteration_count in self.tx_iterations_by_total_iteration_count(
             fork=fork,
             total_iterations=contract_count,
-            start_iteration=contract_start_index,
-            sender=sender,
-            to=to,
-            calldata=calldata,
-        )
+            start_iteration=start_iteration,
+            calldata=calldata_max,
+        ):
+            if (
+                tx_gas_limit is None
+                or tx_gas_cost is None
+                or iteration_count != last_iteration_count
+            ):
+                tx_gas_limit = self.tx_gas_limit_by_iteration_count(
+                    fork=fork,
+                    iteration_count=iteration_count,
+                    start_iteration=start_iteration,
+                    calldata=calldata_max,
+                )
+                tx_gas_cost = self.tx_gas_cost_by_iteration_count(
+                    fork=fork,
+                    iteration_count=iteration_count,
+                    start_iteration=start_iteration,
+                    calldata=calldata_max,
+                )
+            yield TransactionWithCost(
+                to=to,
+                gas_limit=tx_gas_limit,
+                sender=sender,
+                gas_cost=tx_gas_cost,
+                data=calldata(iteration_count, start_iteration),
+            )
+            start_iteration += iteration_count
+            last_iteration_count = iteration_count
 
-    def address(self, *, fork: Fork) -> Address:
-        """Get the deterministic address of the initcode."""
-        return compute_deterministic_create2_address(
-            salt=0,
-            initcode=Initcode(deploy_code=self),
-            fork=fork,
-        )
+    def address(self) -> Address:
+        """Get the deterministic address of the factory contract."""
+        return self._cached_address
 
-    def created_contract_address(self, *, fork: Fork, salt: int) -> Address:
+    def created_contract_address(self, *, salt: int) -> Address:
         """Get the deterministic address of the created contract."""
         return compute_create2_address(
-            address=self.address(fork=fork),
+            address=self.address(),
             salt=salt,
             initcode=self.initcode,
         )

tests/benchmark/compute/scenario/test_unchunkified_bytecode.py

@@ -51,7 +51,7 @@ def test_unchunkified_bytecode(
 
     # Create the max-sized fork-dependent contract factory.
     max_sized_contract_factory = MaxSizedContractFactory(pre=pre, fork=fork)
-    factory_address = max_sized_contract_factory.address(fork=fork)
+    factory_address = max_sized_contract_factory.address()
     initcode = max_sized_contract_factory.initcode
 
     # Prepare the attack iterating bytecode.
@@ -148,9 +148,7 @@ def calldata(iteration_count: int, start_iteration: int) -> bytes:
     post = {}
     for i in range(num_contracts):
         deployed_contract_address = (
-            max_sized_contract_factory.created_contract_address(
-                fork=fork, salt=i
-            )
+            max_sized_contract_factory.created_contract_address(salt=i)
         )
         post[deployed_contract_address] = Account(nonce=1)