feat(specs): Implement EIP-7928: Block-Level Access Lists

fix(tests): Fix Amsterdam filling after rebase
fix(specs): Fix issues with new ruff + mypy rules after rebase

- bal -> block_access_list; re-add custom rlp encoding for block access list
- bytes to uint
- move away from method-style

- Update EIP-7928 implementation: system contracts at index 0, migrate to RLP
  - System contracts (parent hash, beacon root) now use block_access_index 0
  - Transactions use block_access_index 1 to len(transactions)
  - Post-execution changes use block_access_index len(transactions) + 1
  - Migrated from SSZ to RLP encoding as per updated EIP-7928 spec
  - Updated all tests to match new API and structure
  - Replaced tx_index with block_access_index throughout codebase

- add system contract logic
- add markdown docstrings
- update BAL format; address comments
- ssz encoding and bal validation
- six ssz types
- bal tests
- balspecs

fix: do not track setting empty code to a new account (#19)
fix: track implicit SLOAD within SSTORE for OOG cases (#18)
refactor: Put back explicit acct tracking outside 7702 delegation path (#17)
fix non-tracked 7702 authority for invalid delegations (#16)
    * fix non-tracked 7702 authority for invalid delegations
    * fix: lint issues
    * fix: track delegation target when loaded as call target
    * fix: track delegation target when loaded as call target from call
      opcodes
    * chore: fix issues with documentation generation

Fix self-destruct cases with pre-execution balance cache / tracking
    * fix self-destruct implementation
    * fix self-destruct tracking balance
    * fix it in the bal finalization by filtering
    * add balance reset and fix tests
    * simplify pre-balance tracking not using snapshots

fix duplicated code entries for in transaction self destruct
fix self destruct in same transaction bug
fix call/delagate call tracking bug
fix zero-value transfer tracking (#6)
    * fix zero-value transfer tracking
    * fix reverted frame tracking
    * rename variables
    * fix missing addresses bug
    * fix: docs run & move imports to top of file

refactor: move rlp_utils to block_access_lists; bal -> block_access_lists
Some remaining fixes due to large refactor in `forks/osaka`:

- Move BALs from amsterdam -> forks/amsterdam
- rename: build -> build_block_access_list
- fix docc issues

move state change tracker to State

correct system contract addresses

Fixes to communicate with BALs EEST branch:

- fix(bal): Initialize the state tracker before system contract calls

- We were missing system contract calls to beacon roots and history
  contracts. This change initializes the state tracker before system
  contract calls and passes the tracker to these calls if post-Amsterdam.

- fix(docs): Fix issues with toxenvs: lint, doc, json_infra
- fix(t8n): Only initialize the bal_change_tracker for amsterdam
- feat(fork criteria): Index upcoming forks for better ordering / fix issues
- chore(forks): Fix issues from lint after rebase with Osaka latest
- fix(setuptools): Update packages to include amsterdam
- chore(lint): Fix 'tox -e static' issues

- Fix bug in tracker
  Manually cherry-picked from e72991b
  Author: nerolation

- chore(tests): Attempt to resolve issues with CI tests
- chore(lint): fix issues from running ``tox -e static`` locally
- refactor(bal): Send BAL as a list over t8n tool
- fix(amsterdam): Add change tracker to state test in t8n
- chore(lint,tests): Fix tests after moving bal from osaka -> amsterdam
- chore(forks): Move bals from Osaka to Amsterdam
- chore(lint): Fix lint issues

- refactor(bal): Send the full bal object and bal_hash over t8n

  - If we send the full object over JSON, we can model_validate() on ESST.
  - If we send the hash, once we fill the pydantic model, we can get the rlp
    and the hash and validate that our objects match while only really
    validating the parts of the BAL we are interested in for each test.

- chore: point to working eest branch
- chore(bals): Remove unused SSZ utils.py
  The SSZ implementation is no longer needed as we are now using RLP
- refactor(bals): Clean up BAL module types and imports
  - Bytes -> Bytes32 type for storage slots
  - Remove unused imports / fix imports / fix linting
  - Update function signatures to match tracker

- fix(bals-tx-index): Track bal indexes in t8n
  Keep track of BAL index state in t8n

Author: fselmo

.github/configs/feature.yaml

@@ -23,5 +23,6 @@ benchmark_fast:
 
 bal:
   evm-type: develop
-  fill-params: --fork=Amsterdam ./tests/amsterdam/eip7928_block_level_access_lists
+  # TODO: Turn on block rlp limit tests after making filling them more flexible.
+  fill-params: --fork=Amsterdam -k "not eip7934"
   feature_only: true

docs/CHANGELOG.md

@@ -48,6 +48,7 @@ Test fixtures for use by clients are available for each release on the [Github r
 ### 📋 Misc
 
 - 🐞 WELDed the EEST tox environments relevant to producing documentation into EELS, and added a tool to cleanly add codespell whitelist entries. ([#1695](https://github.com/ethereum/execution-specs/pull/1659)).
+- 🐞 Fix duplicate storage write issues for block access lists EIP-7928 implementation ([#1743](https://github.com/ethereum/execution-specs/pull/1743)).
 
 ### 🧪 Test Cases
 

packages/testing/src/execution_testing/cli/pytest_commands/plugins/consume/simulators/helpers/ruleset.py

@@ -296,7 +296,6 @@ def get_blob_schedule_entries(fork: Fork) -> Dict[str, int]:
         "HIVE_CANCUN_TIMESTAMP": 0,
         "HIVE_PRAGUE_TIMESTAMP": 0,
         "HIVE_OSAKA_TIMESTAMP": 0,
-        **get_blob_schedule_entries(Osaka),
     },
     PragueToOsakaAtTime15k: {
         "HIVE_FORK_HOMESTEAD": 0,
@@ -314,7 +313,6 @@ def get_blob_schedule_entries(fork: Fork) -> Dict[str, int]:
         "HIVE_CANCUN_TIMESTAMP": 0,
         "HIVE_PRAGUE_TIMESTAMP": 0,
         "HIVE_OSAKA_TIMESTAMP": 15000,
-        **get_blob_schedule_entries(Osaka),
     },
     BPO1: {
         "HIVE_FORK_HOMESTEAD": 0,
@@ -496,11 +494,10 @@ def get_blob_schedule_entries(fork: Fork) -> Dict[str, int]:
         "HIVE_CANCUN_TIMESTAMP": 0,
         "HIVE_PRAGUE_TIMESTAMP": 0,
         "HIVE_OSAKA_TIMESTAMP": 0,
-        "HIVE_BPO1_TIMESTAMP": 0,
-        "HIVE_BPO2_TIMESTAMP": 0,
-        "HIVE_BPO3_TIMESTAMP": 0,
-        "HIVE_BPO4_TIMESTAMP": 0,
+        # TODO: While we are still reworking BPO interaction with T8N,
+        #  turn off BPO timestamps for now.
+        # "HIVE_BPO1_TIMESTAMP": 0,
+        # "HIVE_BPO2_TIMESTAMP": 0,
         "HIVE_AMSTERDAM_TIMESTAMP": 0,
-        **get_blob_schedule_entries(Amsterdam),
     },
 }

packages/testing/src/execution_testing/client_clis/clis/erigon.py

@@ -56,6 +56,7 @@ class ErigonExceptionMapper(ExceptionMapper):
         BlockException.INVALID_LOG_BLOOM: "invalid bloom",
     }
     mapping_regex = {
+        BlockException.INVALID_BLOCK_ACCESS_LIST: r"invalid block access list|block access list mismatch",
         TransactionException.GAS_LIMIT_EXCEEDS_MAXIMUM: (
             r"invalid block, txnIdx=\d+,.*gas limit too high"
         ),

packages/testing/src/execution_testing/fixtures/blockchain.py

@@ -199,6 +199,9 @@ class FixtureHeader(CamelModel):
     requests_hash: (
         Annotated[Hash, HeaderForkRequirement("requests")] | None
     ) = Field(None)
+    block_access_list_hash: (
+        Annotated[Hash, HeaderForkRequirement("bal_hash")] | None
+    ) = Field(None, alias="blockAccessListHash")
 
     fork: Fork | None = Field(None, exclude=True)
 
@@ -283,6 +286,11 @@ def genesis(cls, fork: Fork, env: Environment, state_root: Hash) -> Self:
             "requests_hash": Requests()
             if fork.header_requests_required(block_number=0, timestamp=0)
             else None,
+            "block_access_list_hash": (
+                BlockAccessList().rlp_hash
+                if fork.header_bal_hash_required(block_number=0, timestamp=0)
+                else None
+            ),
             "fork": fork,
         }
         return cls(**environment_values, **extras)
@@ -408,6 +416,14 @@ def from_fixture_header(
             "Invalid header for engine_newPayload"
         )
 
+        if fork.engine_execution_payload_block_access_list(
+            block_number=header.number, timestamp=header.timestamp
+        ):
+            if block_access_list is None:
+                raise ValueError(
+                    f"`block_access_list` is required in engine `ExecutionPayload` for >={fork}."
+                )
+
         execution_payload = FixtureExecutionPayload.from_fixture_header(
             header=header,
             transactions=transactions,

packages/testing/src/execution_testing/forks/base_fork.py

@@ -345,6 +345,14 @@ def header_requests_required(
         """Return true if the header must contain beacon chain requests."""
         pass
 
+    @classmethod
+    @abstractmethod
+    def header_bal_hash_required(
+        cls, *, block_number: int = 0, timestamp: int = 0
+    ) -> bool:
+        """Return true if the header must contain block access list hash."""
+        pass
+
     # Gas related abstract methods
 
     @classmethod
@@ -710,6 +718,17 @@ def engine_new_payload_target_blobs_per_block(
         """
         pass
 
+    @classmethod
+    @abstractmethod
+    def engine_execution_payload_block_access_list(
+        cls, *, block_number: int = 0, timestamp: int = 0
+    ) -> bool:
+        """
+        Return `True` if the engine api version requires execution payload to
+        include a `block_access_list`.
+        """
+        pass
+
     @classmethod
     @abstractmethod
     def engine_payload_attribute_target_blobs_per_block(

packages/testing/src/execution_testing/forks/forks/forks.py

@@ -443,6 +443,14 @@ def header_requests_required(
         del block_number, timestamp
         return False
 
+    @classmethod
+    def header_bal_hash_required(
+        cls, *, block_number: int = 0, timestamp: int = 0
+    ) -> bool:
+        """At genesis, header must not contain block access list hash."""
+        del block_number, timestamp
+        return False
+
     @classmethod
     def engine_new_payload_version(
         cls, *, block_number: int = 0, timestamp: int = 0
@@ -483,6 +491,14 @@ def engine_new_payload_requests(
         del block_number, timestamp
         return False
 
+    @classmethod
+    def engine_execution_payload_block_access_list(
+        cls, *, block_number: int = 0, timestamp: int = 0
+    ) -> bool:
+        """At genesis, payloads do not have block access list."""
+        del block_number, timestamp
+        return False
+
     @classmethod
     def engine_new_payload_target_blobs_per_block(
         cls,
@@ -2462,6 +2478,16 @@ class BPO5(BPO4, bpo_fork=True):
 class Amsterdam(Osaka):
     """Amsterdam fork."""
 
+    @classmethod
+    def header_bal_hash_required(
+        cls, *, block_number: int = 0, timestamp: int = 0
+    ) -> bool:
+        """
+        From Amsterdam, header must contain block access list hash (EIP-7928).
+        """
+        del block_number, timestamp
+        return True
+
     @classmethod
     def is_deployed(cls) -> bool:
         """Return True if this fork is deployed."""
@@ -2475,6 +2501,17 @@ def engine_new_payload_version(
         del block_number, timestamp
         return 5
 
+    @classmethod
+    def engine_execution_payload_block_access_list(
+        cls, *, block_number: int = 0, timestamp: int = 0
+    ) -> bool:
+        """
+        From Amsterdam, engine execution payload includes `block_access_list`
+        as a parameter.
+        """
+        del block_number, timestamp
+        return True
+
 
 class EOFv1(Prague, solc_name="cancun"):
     """EOF fork."""

packages/testing/src/execution_testing/specs/blockchain.py

@@ -551,11 +551,16 @@ def make_genesis(
         state_root = pre_alloc.state_root()
         genesis = FixtureHeader.genesis(self.fork, env, state_root)
 
+        genesis_bal = None
+        if self.fork.header_bal_hash_required(block_number=0, timestamp=0):
+            genesis_bal = BlockAccessList()
+
         return (
             pre_alloc,
             FixtureBlockBase(
                 header=genesis,
                 withdrawals=None if env.withdrawals is None else [],
+                block_access_list=genesis_bal,
             ).with_rlp(txs=[]),
         )
 
@@ -687,6 +692,24 @@ def generate_block_data(
             )
             requests_list = block.requests
 
+        if self.fork.header_bal_hash_required(
+            block_number=header.number, timestamp=header.timestamp
+        ):
+            assert (
+                transition_tool_output.result.block_access_list is not None
+            ), (
+                "Block access list is required for this block but was not provided "
+                "by the transition tool"
+            )
+
+            rlp = transition_tool_output.result.block_access_list.rlp
+            computed_bal_hash = Hash(rlp.keccak256())
+            assert computed_bal_hash == header.block_access_list_hash, (
+                "Block access list hash in header does not match the "
+                f"computed hash from BAL: {header.block_access_list_hash} "
+                f"!= {computed_bal_hash}"
+            )
+
         if block.rlp_modifier is not None:
             # Modify any parameter specified in the `rlp_modifier` after
             # transition tool processing.
@@ -695,6 +718,29 @@ def generate_block_data(
                 self.fork
             )  # Deleted during `apply` because `exclude=True`
 
+        # Process block access list - apply transformer if present for invalid
+        # tests
+        t8n_bal = transition_tool_output.result.block_access_list
+        bal = t8n_bal
+
+        # Always validate BAL structural integrity (ordering, duplicates) if present
+        if t8n_bal is not None:
+            t8n_bal.validate_structure()
+
+        # If expected BAL is defined, verify against it
+        if (
+            block.expected_block_access_list is not None
+            and t8n_bal is not None
+        ):
+            block.expected_block_access_list.verify_against(t8n_bal)
+
+            bal = block.expected_block_access_list.modify_if_invalid_test(
+                t8n_bal
+            )
+            if bal != t8n_bal:
+                # If the BAL was modified, update the header hash
+                header.block_access_list_hash = Hash(bal.rlp.keccak256())
+
         built_block = BuiltBlock(
             header=header,
             alloc=transition_tool_output.alloc,
@@ -708,7 +754,7 @@ def generate_block_data(
             expected_exception=block.exception,
             engine_api_error_code=block.engine_api_error_code,
             fork=self.fork,
-            block_access_list=None,
+            block_access_list=bal,
         )
 
         try:

packages/testing/src/execution_testing/test_types/block_access_list/account_absent_values.py

@@ -52,14 +52,14 @@ class BalAccountAbsentValues(CamelModel):
         absent_values = BalAccountAbsentValues(
             nonce_changes=[
                 # Forbid exact nonce change at this tx
-                BalNonceChange(tx_index=1, post_nonce=5),
+                BalNonceChange(block_access_index=1, post_nonce=5),
             ],
             storage_changes=[
                 BalStorageSlot(
                     slot=0x42,
                     slot_changes=[
                         # Forbid exact storage change at this slot and tx
-                        BalStorageChange(tx_index=2, post_value=0x99)
+                        BalStorageChange(block_access_index=2, post_value=0x99)
                     ],
                 )
             ],
@@ -173,22 +173,23 @@ def validate_against(self, account: BalAccountChange) -> None:
         self._validate_forbidden_changes(
             account.nonce_changes,
             self.nonce_changes,
-            lambda a, f: a.tx_index == f.tx_index
+            lambda a, f: a.block_access_index == f.block_access_index
             and a.post_nonce == f.post_nonce,
-            lambda a: f"Unexpected nonce change found at tx {a.tx_index}",
+            lambda a: f"Unexpected nonce change found at tx {a.block_access_index}",
         )
         self._validate_forbidden_changes(
             account.balance_changes,
             self.balance_changes,
-            lambda a, f: a.tx_index == f.tx_index
+            lambda a, f: a.block_access_index == f.block_access_index
             and a.post_balance == f.post_balance,
-            lambda a: f"Unexpected balance change found at tx {a.tx_index}",
+            lambda a: f"Unexpected balance change found at tx {a.block_access_index}",
         )
         self._validate_forbidden_changes(
             account.code_changes,
             self.code_changes,
-            lambda a, f: a.tx_index == f.tx_index and a.new_code == f.new_code,
-            lambda a: f"Unexpected code change found at tx {a.tx_index}",
+            lambda a, f: a.block_access_index == f.block_access_index
+            and a.new_code == f.new_code,
+            lambda a: f"Unexpected code change found at tx {a.block_access_index}",
         )
 
         for forbidden_storage_slot in self.storage_changes:
@@ -199,11 +200,11 @@ def validate_against(self, account: BalAccountChange) -> None:
                         actual_storage_slot.slot_changes,
                         forbidden_storage_slot.slot_changes,
                         lambda a, f: (
-                            a.tx_index == f.tx_index
+                            a.block_access_index == f.block_access_index
                             and a.post_value == f.post_value
                         ),
                         lambda a, slot=slot_id: (
-                            f"Unexpected storage change found at slot {slot} in tx {a.tx_index}"
+                            f"Unexpected storage change found at slot {slot} in tx {a.block_access_index}"
                         ),
                     )