enable BPO1 and BPO2 for Amsterdam

.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,
@@ -498,9 +496,6 @@ def get_blob_schedule_entries(fork: Fork) -> Dict[str, int]:
         "HIVE_OSAKA_TIMESTAMP": 0,
         "HIVE_BPO1_TIMESTAMP": 0,
         "HIVE_BPO2_TIMESTAMP": 0,
-        "HIVE_BPO3_TIMESTAMP": 0,
-        "HIVE_BPO4_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: