temp

Author: LouisTsai-Csie

tests/benchmark/stateful/bloatnet/test_setup_contracts.py

@@ -6,16 +6,22 @@
     BenchmarkTestFiller,
     Fork,
     Hash,
+    Op,
     Transaction,
 )
 
 from tests.benchmark.stateful.helpers import (
     AccountMode,
     account_mode_initcode,
+    account_mode_runtime_size,
     pack_transactions_into_blocks,
 )
 
-RECEIVER_CONTRACT_COUNT = 5
+# Distinct contracts deployed per account mode. Sized for the most
+# demanding consumer, test_account_access, whose cheapest iteration is
+# ~2,691 gas: a 300M block reaches ~111,482 distinct salts, rounded up
+# with margin.
+RECEIVER_CONTRACT_COUNT = 120_000
 
 CONTRACT_MODES = [
     AccountMode.EXISTING_CONTRACT_MINIMAL,
@@ -24,11 +30,31 @@
     AccountMode.EXISTING_CONTRACT_JUMPDEST,
 ]
 
-# Generous per-deployment gas limit. A max-size contract deposit costs
-# ~54M under EIP-8037; the single-byte runtime is far cheaper but the
-# same limit is harmless. Kept well below the block budget so many
-# deployments pack into one block.
-DEPLOYMENT_TX_GAS_LIMIT = 80_000_000
+
+def deployment_gas_limit(
+    fork: Fork, initcode: bytes, runtime_size: int
+) -> int:
+    """
+    Return the gas limit for one CREATE2 deployment, derived from the
+    intrinsic, CREATE2, and code-deposit costs with a small margin.
+    """
+    intrinsic = fork.transaction_intrinsic_cost_calculator()(
+        calldata=Hash(0) + initcode
+    )
+    create_cost = Op.CREATE2(
+        value=0,
+        offset=0,
+        size=len(initcode),
+        salt=0,
+        init_code_size=len(initcode),
+    ).gas_cost(fork)
+    deposit_cost = Op.RETURN(
+        0,
+        runtime_size,
+        code_deposit_size=runtime_size,
+    ).gas_cost(fork)
+    base = intrinsic + create_cost + deposit_cost
+    return base + base // 16
 
 
 def test_deploy_existing_contracts(
@@ -43,20 +69,23 @@ def test_deploy_existing_contracts(
 
     Runs once as a global setup before the bloatnet benchmarks; the
     transactions intentionally carry no test phase so that the payload
-    pipeline replays them ahead of every scenario. Deployments are
-    packed into blocks up to the block gas budget so each block carries
-    many transactions instead of one.
+    pipeline replays them ahead of every scenario. Each deployment's
+    gas limit is computed from its cost, then transactions are packed
+    into blocks up to the block gas budget.
     """
     txs = []
     for account_mode in CONTRACT_MODES:
         initcode = account_mode_initcode(fork, account_mode)
+        gas_limit = deployment_gas_limit(
+            fork, initcode, account_mode_runtime_size(fork, account_mode)
+        )
         sender = pre.fund_eoa()
         for salt in range(RECEIVER_CONTRACT_COUNT):
             txs.append(
                 Transaction(
                     to=DETERMINISTIC_FACTORY_ADDRESS,
                     data=Hash(salt) + initcode,
-                    gas_limit=DEPLOYMENT_TX_GAS_LIMIT,
+                    gas_limit=gas_limit,
                     sender=sender,
                 )
             )

tests/benchmark/stateful/helpers.py

@@ -93,6 +93,10 @@ def build_existing_contract_initcode(
     return code
 
 
+# Runtime size of the jochemnet unique-code contract (EIP-170 limit).
+JOCHEMNET_RUNTIME_SIZE = 0x6000
+
+
 def build_unique_contract_initcode() -> bytes:
     """
     Deployed runtime contract layout.
@@ -109,7 +113,7 @@ def build_unique_contract_initcode() -> bytes:
     Embedded ADDRESS makes runtime unique per contract;
     initcode and its CREATE2 hash is shared across all salts.
     """
-    max_code_size = 0x6000  # EIP-170 contract code size limit
+    max_code_size = JOCHEMNET_RUNTIME_SIZE
 
     # MCOPY fills MEM[0:0x8000] with JUMPDEST.
     # Runtime only uses MEM[0:0x6000].
@@ -149,6 +153,17 @@ def account_mode_initcode(fork: Fork, account_mode: AccountMode) -> bytes:
     return bytes(build_existing_contract_initcode(fork, account_mode))
 
 
+def account_mode_runtime_size(fork: Fork, account_mode: AccountMode) -> int:
+    """
+    Return the deployed runtime size in bytes for the account mode.
+    """
+    if account_mode == AccountMode.EXISTING_CONTRACT_MINIMAL:
+        return 1
+    if account_mode == AccountMode.EXISTING_CONTRACT_JUMPDEST:
+        return JOCHEMNET_RUNTIME_SIZE
+    return fork.max_code_size()
+
+
 def build_benchmark_txs(
     *,
     pre: Alloc,