Move verify_and_notify_new_payload to Bellatrix

setup.py

@@ -604,6 +604,13 @@ def get_payload(self: ExecutionEngine, payload_id: PayloadId) -> GetPayloadRespo
         # pylint: disable=unused-argument
         raise NotImplementedError("no default block production")
 
+    def is_valid_block_hash(self: ExecutionEngine, execution_payload: ExecutionPayload) -> bool:
+        return True
+
+    def verify_and_notify_new_payload(self: ExecutionEngine,
+                                      new_payload_request: NewPayloadRequest) -> bool:
+        return True
+
 
 EXECUTION_ENGINE = NoopExecutionEngine()"""
 

specs/bellatrix/beacon-chain.md

@@ -320,13 +320,13 @@ The implementation-dependent `ExecutionEngine` protocol encapsulates the executi
 * a state object `self.execution_state` of type `ExecutionState`
 * a notification function `self.notify_new_payload` which may apply changes to the `self.execution_state`
 
-*Note*: `notify_new_payload` is a function accessed through the `EXECUTION_ENGINE` module which instantiates the `ExecutionEngine` protocol.
-
-The body of this function is implementation dependent.
+The body of these functions are implementation dependent.
 The Engine API may be used to implement this and similarly defined functions via an external execution engine.
 
 #### `notify_new_payload`
 
+`notify_new_payload` is a function accessed through the `EXECUTION_ENGINE` module which instantiates the `ExecutionEngine` protocol.
+
 ```python
 def notify_new_payload(self: ExecutionEngine, execution_payload: ExecutionPayload) -> bool:
     """
@@ -335,6 +335,30 @@ def notify_new_payload(self: ExecutionEngine, execution_payload: ExecutionPayloa
     ...
 ```
 
+#### `is_valid_block_hash`
+
+```python
+def is_valid_block_hash(self: ExecutionEngine, execution_payload: ExecutionPayload) -> bool:
+    """
+    Return ``True`` if and only if ``execution_payload.block_hash`` is computed correctly.
+    """
+    ...
+```
+
+#### `verify_and_notify_new_payload`
+
+```python
+def verify_and_notify_new_payload(self: ExecutionEngine,
+                                  new_payload_request: NewPayloadRequest) -> bool:
+    """
+    Return ``True`` if and only if ``new_payload_request`` is valid with respect to ``self.execution_state``.
+    """
+    assert self.is_valid_block_hash(new_payload_request.execution_payload)
+    assert self.notify_new_payload(new_payload_request.execution_payload)
+    ...
+    return True
+```
+
 ### Block processing
 
 *Note*: The call to the `process_execution_payload` must happen before the call to the `process_randao` as the former depends on the `randao_mix` computed with the reveal of the previous block.
@@ -366,7 +390,7 @@ def process_execution_payload(state: BeaconState, body: BeaconBlockBody, executi
     # Verify timestamp
     assert payload.timestamp == compute_timestamp_at_slot(state, state.slot)
     # Verify the execution payload is valid
-    assert execution_engine.notify_new_payload(payload)
+    assert execution_engine.verify_and_notify_new_payload(NewPayloadRequest(execution_payload=payload))
     # Cache execution payload header
     state.latest_execution_payload_header = ExecutionPayloadHeader(
         parent_hash=payload.parent_hash,

specs/capella/beacon-chain.md

@@ -418,7 +418,7 @@ def process_execution_payload(state: BeaconState, body: BeaconBlockBody, executi
     # Verify timestamp
     assert payload.timestamp == compute_timestamp_at_slot(state, state.slot)
     # Verify the execution payload is valid
-    assert execution_engine.notify_new_payload(payload)
+    assert execution_engine.verify_and_notify_new_payload(NewPayloadRequest(execution_payload=payload))
     # Cache execution payload header
     state.latest_execution_payload_header = ExecutionPayloadHeader(
         parent_hash=payload.parent_hash,

specs/deneb/beacon-chain.md

@@ -179,16 +179,6 @@ class NewPayloadRequest(object):
 
 #### Engine APIs
 
-#### `is_valid_block_hash`
-
-```python
-def is_valid_block_hash(self: ExecutionEngine, execution_payload: ExecutionPayload) -> bool:
-    """
-    Return ``True`` if and only if ``execution_payload.block_hash`` is computed correctly.
-    """
-    ...
-```
-
 #### `is_valid_versioned_hashes`
 
 ```python
@@ -200,7 +190,7 @@ def is_valid_versioned_hashes(self: ExecutionEngine, new_payload_request: NewPay
     ...
 ```
 
-#### `verify_and_notify_new_payload`
+#### Modified `verify_and_notify_new_payload`
 
 ```python
 def verify_and_notify_new_payload(self: ExecutionEngine,
@@ -209,7 +199,7 @@ def verify_and_notify_new_payload(self: ExecutionEngine,
     Return ``True`` if and only if ``new_payload_request`` is valid with respect to ``self.execution_state``.
     """
     assert self.is_valid_block_hash(new_payload_request.execution_payload)
-    assert self.is_valid_versioned_hashes(new_payload_request)
+    assert self.is_valid_versioned_hashes(new_payload_request)  # [Modified in Deneb]
     assert self.notify_new_payload(new_payload_request.execution_payload)
     ...
     return True

sync/optimistic.md

@@ -159,7 +159,7 @@ these conditions.*
 
 To optimistically import a block:
 
-- The [`notify_new_payload`](../specs/bellatrix/beacon-chain.md#notify_new_payload) function MUST return `True` if the execution
+- The [`verify_and_notify_new_payload`](../specs/bellatrix/beacon-chain.md#verify_and_notify_new_payload) function MUST return `True` if the execution
   engine returns `NOT_VALIDATED` or `VALID`. An `INVALIDATED` response MUST return `False`.
 - The [`validate_merge_block`](../specs/bellatrix/fork-choice.md#validate_merge_block)
  function MUST NOT raise an assertion if both the
@@ -172,7 +172,7 @@ In addition to this change in validation, the consensus engine MUST track which
 blocks returned `NOT_VALIDATED` and which returned `VALID` for subsequent processing.
 
 Optimistically imported blocks MUST pass all verifications included in
-`process_block` (withstanding the modifications to `notify_new_payload`).
+`process_block` (withstanding the modifications to `verify_and_notify_new_payload`).
 
 A consensus engine MUST be able to retrospectively (i.e., after import) modify
 the status of `NOT_VALIDATED` blocks to be either `VALID` or `INVALIDATED` based upon responses

tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_execution_payload.py

@@ -31,12 +31,6 @@ def run_execution_payload_processing(spec, state, execution_payload, valid=True,
     called_new_block = False
 
     class TestEngine(spec.NoopExecutionEngine):
-        def notify_new_payload(self, payload) -> bool:
-            nonlocal called_new_block, execution_valid
-            called_new_block = True
-            assert payload == execution_payload
-            return execution_valid
-
         def verify_and_notify_new_payload(self, new_payload_request) -> bool:
             nonlocal called_new_block, execution_valid
             called_new_block = True

tests/core/pyspec/eth2spec/test/helpers/optimistic_sync.py

@@ -91,7 +91,7 @@ def add_optimistic_block(spec, mega_store, signed_block, test_steps,
     Add a block with optimistic sync logic
 
     ``valid`` indicates if the given ``signed_block.message.body.execution_payload`` is valid/invalid
-    from ``notify_new_payload`` method response.
+    from ``verify_and_notify_new_payload`` method response.
     """
     block = signed_block.message
     block_root = block.hash_tree_root()