feat: add eoa delegation target

LouisTsai-Csie · LouisTsai-Csie · commit 7ea7b98486dc · 2026-06-17T22:24:25.000+08:00
diff --git a/tests/benchmark/helper/account_sender_receiver.py b/tests/benchmark/helper/account_sender_receiver.py
@@ -0,0 +1,80 @@
+"""Deterministic benchmark sender and receiver accounts."""
+
+import itertools
+from typing import Generator
+
+from execution_testing import (
+    DETERMINISTIC_FACTORY_ADDRESS,
+    EOA,
+    Address,
+    compute_create2_address,
+    compute_create_address,
+    keccak256,
+)
+
+# Deterministic sender pool, pre-funded via system-contract withdrawals
+# (funding.txt) during payload generation. Kept out of the pre-allocation so
+# the accounts stay uncached.
+SENDER_BASE_KEY = int.from_bytes(
+    keccak256(b"gas-repricings-private-key"), "big"
+)
+
+# Deterministic EIP-7702 delegate authorities:
+# Authority i delegates to EXISTING_CONTRACT_DIFF receiver i.
+DELEGATE_BASE_KEY = int.from_bytes(
+    keccak256(b"gas-repricings-7702-delegate"), "big"
+)
+
+# Bittrex controller mainnet address: it created 1.5M contracts via CREATE with
+# deterministic addresses, none self-destructed. Used as existing-contract
+# receivers.
+BITTREX_CONTROLLER_ADDRESS = Address(
+    0xA3C1E324CA1CE40DB73ED6026C4A177F099B5770
+)
+
+
+def yield_distinct_sender() -> Generator[EOA, None, None]:
+    """Yield deterministic sender EOAs pre-funded on-chain."""
+    for i in itertools.count(0):
+        yield EOA(key=SENDER_BASE_KEY + i)
+
+
+def yield_distinct_create2_receiver(
+    initcode: bytes,
+) -> Generator[Address, None, None]:
+    """Yield addresses deployed by the deterministic CREATE2 factory."""
+    for salt in itertools.count(0):
+        yield compute_create2_address(
+            address=DETERMINISTIC_FACTORY_ADDRESS,
+            salt=salt,
+            initcode=initcode,
+        )
+
+
+def yield_distinct_contract_receiver() -> Generator[Address, None, None]:
+    """Yield contracts created by the Bittrex controller via CREATE."""
+    for nonce in itertools.count(2):
+        yield compute_create_address(
+            address=BITTREX_CONTROLLER_ADDRESS, nonce=nonce
+        )
+
+
+def yield_distinct_existent_receiver() -> Generator[Address, None, None]:
+    """
+    Yield existing balance-only EOAs on bloatnet, pre-funded by Spamoor
+    (https://github.com/CPerezz/spamoor/pull/12).
+    """
+    for address in itertools.count(0x1000):
+        yield Address(address)
+
+
+def yield_distinct_nonexistent_receiver() -> Generator[Address, None, None]:
+    """Yield non-existent accounts starting from keccak256('random')."""
+    for address in itertools.count(0xF3CF193BB4AF1022AF7D2089F37D8BAE7157B85F):
+        yield Address(address)
+
+
+def yield_distinct_delegate_receiver() -> Generator[Address, None, None]:
+    """Yield EOA that delegates to distinct EXISTING_CONTRACT_DIFF receiver."""
+    for i in itertools.count(0):
+        yield EOA(key=DELEGATE_BASE_KEY + i)
diff --git a/tests/benchmark/stateful/bloatnet/test_setup_contracts.py b/tests/benchmark/stateful/bloatnet/test_setup_contracts.py
@@ -2,21 +2,29 @@
 
 from execution_testing import (
     DETERMINISTIC_FACTORY_ADDRESS,
+    EOA,
+    Account,
     Alloc,
+    AuthorizationTuple,
     BenchmarkTestFiller,
     Fork,
     Hash,
     Op,
     Transaction,
+    compute_create2_address,
 )
 
 from tests.benchmark.helper.account_creator import (
     AccountCreator,
     AccountMode,
 )
+from tests.benchmark.helper.account_sender_receiver import (
+    DELEGATE_BASE_KEY,
+)
 from tests.benchmark.stateful.helpers import (
     pack_transactions_into_blocks,
 )
+from tests.prague.eip7702_set_code_tx.spec import Spec as Spec7702
 
 RECEIVER_CONTRACT_COUNT = 120_000
 
@@ -58,12 +66,16 @@ def test_deploy_existing_contracts(
     pre: Alloc,
     fork: Fork,
     gas_benchmark_value: int,
+    tx_gas_limit: int,
 ) -> None:
     """
     Deploy the contracts behind the `AccountMode.EXISTING_CONTRACT_*`
     receivers via the deterministic CREATE2 factory.
+
+    Delegate deterministic EOAs to EXISTING_CONTRACT_DIFF receivers.
     """
     txs = []
+    post: dict = {}
     for account_mode in CONTRACT_MODES:
         creator = AccountCreator(account_mode)
         initcode = creator.initcode
@@ -79,10 +91,52 @@ def test_deploy_existing_contracts(
                 )
             )
 
-    blocks = pack_transactions_into_blocks(txs, gas_benchmark_value)
+    # Delegate authority i to the i-th DIFF receiver (EIP-7702).
+    delegation_sender = pre.fund_eoa()
+    intrinsic = fork.transaction_intrinsic_cost_calculator()
+    # DIFF receivers share one initcode; build it once for CREATE2 derivation.
+    diff_initcode = AccountCreator(AccountMode.EXISTING_CONTRACT_DIFF).initcode
+
+    base_gas = intrinsic(authorization_list_or_count=0)
+    per_auth_gas = intrinsic(authorization_list_or_count=1) - base_gas
+    gas_buffer = 100_000
+    auths_per_tx = max(
+        1, (tx_gas_limit - gas_buffer - base_gas) // per_auth_gas
+    )
+
+    for start in range(0, RECEIVER_CONTRACT_COUNT, auths_per_tx):
+        count = min(auths_per_tx, RECEIVER_CONTRACT_COUNT - start)
+        authorization_list = []
+        for i in range(start, start + count):
+            authority = EOA(key=DELEGATE_BASE_KEY + i)
+            target = compute_create2_address(
+                address=DETERMINISTIC_FACTORY_ADDRESS,
+                salt=i,
+                initcode=diff_initcode,
+            )
+            authorization_list.append(
+                AuthorizationTuple(address=target, nonce=0, signer=authority)
+            )
+            if i == 0 or i == RECEIVER_CONTRACT_COUNT - 1:
+                post[authority] = Account(
+                    nonce=1,
+                    code=Spec7702.delegation_designation(target),
+                )
+
+        txs.append(
+            Transaction(
+                to=delegation_sender,
+                gas_limit=(
+                    intrinsic(authorization_list_or_count=count) + gas_buffer
+                ),
+                sender=delegation_sender,
+                authorization_list=authorization_list,
+            )
+        )
 
     benchmark_test(
-        blocks=blocks,
+        post=post,
+        blocks=pack_transactions_into_blocks(txs, gas_benchmark_value),
         skip_gas_used_validation=True,
         expected_receipt_status=1,
     )
diff --git a/tests/benchmark/stateful/bloatnet/test_transaction_types.py b/tests/benchmark/stateful/bloatnet/test_transaction_types.py
@@ -1,89 +1,32 @@
 """Benchmark ether transfers to receivers that exist on-chain."""
 
-import itertools
 from typing import Generator
 
 import pytest
 from execution_testing import (
-    DETERMINISTIC_FACTORY_ADDRESS,
-    EOA,
     Address,
     Alloc,
     BenchmarkTestFiller,
     Block,
     Fork,
     Op,
     Transaction,
-    compute_create2_address,
-    compute_create_address,
-    keccak256,
 )
 
 from tests.benchmark.helper.account_creator import (
     AccountCreator,
     AccountMode,
 )
-
-# Deterministic sender pool of 15K accounts.
-# Funded via system contract withdrawals (funding.txt) in payload generation.
-# Placed outside pre-allocation to ensure accounts remain uncached.
-SENDER_BASE_KEY = int.from_bytes(
-    keccak256(b"gas-repricings-private-key"), "big"
-)
-
-
-def yield_distinct_sender() -> Generator[EOA, None, None]:
-    """Yield deterministic sender EOAs pre-funded on-chain."""
-    for i in itertools.count(0):
-        yield EOA(key=SENDER_BASE_KEY + i)
-
-
-def yield_distinct_create2_receiver(
-    initcode: bytes,
-) -> Generator[Address, None, None]:
-    """
-    Yield contract addresses deployed by the deterministic CREATE2 factory.
-    """
-    for salt in itertools.count(0):
-        yield compute_create2_address(
-            address=DETERMINISTIC_FACTORY_ADDRESS,
-            salt=salt,
-            initcode=initcode,
-        )
-
-
-# Bittrex controller mainnet address
-# Creates 1.5M contracts with deterministic address via CREATE
-# It is guaranteed no contract is destructed
-# Used for existing contract targets in benchmark
-BITTREX_CONTROLLER_ADDRESS = Address(
-    0xA3C1E324CA1CE40DB73ED6026C4A177F099B5770
+from tests.benchmark.helper.account_sender_receiver import (
+    yield_distinct_contract_receiver,
+    yield_distinct_create2_receiver,
+    yield_distinct_delegate_receiver,
+    yield_distinct_existent_receiver,
+    yield_distinct_nonexistent_receiver,
+    yield_distinct_sender,
 )
 
 
-def yield_distinct_contract_receiver() -> Generator[Address, None, None]:
-    """Yield contract account created by Bittrex controller via CREATE."""
-    for nonce in itertools.count(2):
-        yield compute_create_address(
-            address=BITTREX_CONTROLLER_ADDRESS, nonce=nonce
-        )
-
-
-def yield_distinct_existent_receiver() -> Generator[Address, None, None]:
-    """
-    Yield existing balance-only EOA on bloatnet. pre-funded by Spamoor
-    (https://github.com/CPerezz/spamoor/pull/12).
-    """
-    for address in itertools.count(0x1000):
-        yield Address(address)
-
-
-def yield_distinct_nonexistent_receiver() -> Generator[Address, None, None]:
-    """Yield non-existent accounts starting from keccak256('random')."""
-    for address in itertools.count(0xF3CF193BB4AF1022AF7D2089F37D8BAE7157B85F):
-        yield Address(address)
-
-
 @pytest.mark.repricing
 @pytest.mark.parametrize(
     "case_id",
@@ -96,6 +39,7 @@ def yield_distinct_nonexistent_receiver() -> Generator[Address, None, None]:
         "diff_to_contract_minimal",
         "diff_to_contract_same",
         "diff_to_contract_diff",
+        "diff_to_delegated_contract_diff",
     ],
 )
 @pytest.mark.parametrize("transfer_amount", [0, 1])
@@ -146,6 +90,8 @@ def test_ether_transfers_onchain_receivers(
             receivers = yield_distinct_create2_receiver(
                 AccountCreator(AccountMode.EXISTING_CONTRACT_DIFF).initcode
             )
+        case "diff_to_delegated_contract_diff":
+            receivers = yield_distinct_delegate_receiver()
         case _:
             raise ValueError(f"Unknown case: {case_id}")
 
