EIP-7332 Refactor Beacon chain state transition function

Author: StefanBratanov

specs/_features/eip7732/beacon-chain.md

@@ -50,10 +50,9 @@
       - [Modified `process_operations`](#modified-process_operations)
       - [Payload Attestations](#payload-attestations)
         - [`process_payload_attestation`](#process_payload_attestation)
-    - [Modified `process_execution_payload`](#modified-process_execution_payload)
-      - [New `verify_execution_payload_envelope_signature`](#new-verify_execution_payload_envelope_signature)
     - [Modified `is_merge_transition_complete`](#modified-is_merge_transition_complete)
     - [Modified `validate_merge_block`](#modified-validate_merge_block)
+  - [Execution payload processing](#execution-payload-processing)   
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 <!-- /TOC -->
@@ -415,19 +414,49 @@ def get_indexed_payload_attestation(state: BeaconState, slot: Slot,
 
 ## Beacon chain state transition function
 
-*Note*: state transition is fundamentally modified in EIP-7732. The full state transition is broken in two parts, first importing a signed block and then importing an execution payload.
+### Modified `state_transition`
 
-The post-state corresponding to a pre-state `state` and a signed beacon block `signed_block` is defined as `state_transition(state, signed_block)`. State transitions that trigger an unhandled exception (e.g. a failed `assert` or an out-of-range list access) are considered invalid. State transitions that cause a `uint64` overflow or underflow are also considered invalid.
+**Note:** This is modified to accept `signed_envelope` as an additional parameter. The state transition has been broken in two parts, first importing a signed block and then importing an execution payload. Even though the order must be followed, importing of the signed block and the execution payload can be done indepedently. 
 
-The post-state corresponding to a pre-state `state` and a signed execution payload envelope `signed_envelope` is defined as `process_execution_payload(state, signed_envelope)`. State transitions that trigger an unhandled exception (e.g. a failed `assert` or an out-of-range list access) are considered invalid. State transitions that cause an `uint64` overflow or underflow are also considered invalid.
+```python
+def state_transition(state: BeaconState, signed_block: SignedBeaconBlock, signed_envelope: SignedExecutionPayloadEnvelope, validate_result: bool=True) -> None:
+    block = signed_block.message
+    # Process slots (including those with no blocks) since block
+    process_slots(state, block.slot)
+    # Verify block signature
+    if validate_result:
+        assert verify_block_signature(state, signed_block)
+    # Process block
+    process_block(state, block)
+    # Verify state root
+    if validate_result:
+        assert block.state_root == hash_tree_root(state)
+    # Verify execution payload signature
+    if validate_result:
+        assert verify_execution_payload_envelope_signature(state, signed_envelope) # [New in EIP-7732]
+    # Process execution payload
+    process_execution_payload(state, signed_envelope, EXECUTION_ENGINE) # [New in EIP-7732]
+    # Verify state root
+    if validate_result:
+        assert signed_envelope.message.state_root == hash_tree_root(state) # [New in EIP-7732]    
+```
+
+```python
+def verify_execution_payload_envelope_signature(
+        state: BeaconState, signed_envelope: SignedExecutionPayloadEnvelope) -> bool:
+    builder = state.validators[signed_envelope.message.builder_index]
+    signing_root = compute_signing_root(signed_envelope.message, get_domain(state, DOMAIN_BEACON_BUILDER))
+    return bls.Verify(builder.pubkey, signing_root, signed_envelope.signature)
+```
 
 ### Block processing
 
 ```python
 def process_block(state: BeaconState, block: BeaconBlock) -> None:
     process_block_header(state, block)
     process_withdrawals(state)  # [Modified in EIP-7732]
-    process_execution_payload_header(state, block)  # [Modified in EIP-7732, removed process_execution_payload]
+    # Removed `process_execution_payload` in EIP-7732
+    process_execution_payload_header(state, block)  # [New in EIP-7732]
     process_randao(state, block.body)
     process_eth1_data(state, block.body)
     process_operations(state, block.body)  # [Modified in EIP-7732]
@@ -592,27 +621,54 @@ def process_payload_attestation(state: BeaconState, payload_attestation: Payload
     increase_balance(state, proposer_index, proposer_reward)
 ```
 
-#### Modified `process_execution_payload`
+#### Modified `is_merge_transition_complete`
 
-##### New `verify_execution_payload_envelope_signature`
+`is_merge_transition_complete` is modified only for testing purposes to add the blob kzg commitments root for an empty list
 
 ```python
-def verify_execution_payload_envelope_signature(
-        state: BeaconState, signed_envelope: SignedExecutionPayloadEnvelope) -> bool:
-    builder = state.validators[signed_envelope.message.builder_index]
-    signing_root = compute_signing_root(signed_envelope.message, get_domain(state, DOMAIN_BEACON_BUILDER))
-    return bls.Verify(builder.pubkey, signing_root, signed_envelope.signature)
+def is_merge_transition_complete(state: BeaconState) -> bool:
+    header = ExecutionPayloadHeader()
+    kzgs = List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]()
+    header.blob_kzg_commitments_root = kzgs.hash_tree_root()
+
+    return state.latest_execution_payload_header != header
+```
+
+#### Modified `validate_merge_block`
+`validate_merge_block` is modified to use the new `signed_execution_payload_header` message in the Beacon Block Body
+
+```python
+def validate_merge_block(block: BeaconBlock) -> None:
+    """
+    Check the parent PoW block of execution payload is a valid terminal PoW block.
+
+    Note: Unavailable PoW block(s) may later become available,
+    and a client software MAY delay a call to ``validate_merge_block``
+    until the PoW block(s) become available.
+    """
+    if TERMINAL_BLOCK_HASH != Hash32():
+        # If `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
+        assert compute_epoch_at_slot(block.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
+        assert block.body.signed_execution_payload_header.message.parent_block_hash == TERMINAL_BLOCK_HASH
+        return
+
+    # Modified in EIP-7732
+    pow_block = get_pow_block(block.body.signed_execution_payload_header.message.parent_block_hash)
+    # Check if `pow_block` is available
+    assert pow_block is not None
+    pow_parent = get_pow_block(pow_block.parent_hash)
+    # Check if `pow_parent` is available
+    assert pow_parent is not None
+    # Check if `pow_block` is a valid terminal PoW block
+    assert is_valid_terminal_pow_block(pow_block, pow_parent)
 ```
 
-*Note*: `process_execution_payload` is now an independent check in state transition. It is called when importing a signed execution payload proposed by the builder of the current slot.
+### Execution payload processing
 
 ```python
 def process_execution_payload(state: BeaconState, 
                               signed_envelope: SignedExecutionPayloadEnvelope, 
-                              execution_engine: ExecutionEngine, verify: bool = True) -> None:
-    # Verify signature
-    if verify: 
-        assert verify_execution_payload_envelope_signature(state, signed_envelope)
+                              execution_engine: ExecutionEngine) -> None:
     envelope = signed_envelope.message
     payload = envelope.payload
     # Cache latest block header state root
@@ -667,50 +723,4 @@ def process_execution_payload(state: BeaconState,
         # Cache the execution payload header and proposer
         state.latest_block_hash = payload.block_hash
         state.latest_full_slot = state.slot
-
-    # Verify the state root
-    if verify: 
-        assert envelope.state_root == hash_tree_root(state)
-```
-
-#### Modified `is_merge_transition_complete`
-
-`is_merge_transition_complete` is modified only for testing purposes to add the blob kzg commitments root for an empty list
-
-```python
-def is_merge_transition_complete(state: BeaconState) -> bool:
-    header = ExecutionPayloadHeader()
-    kzgs = List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]()
-    header.blob_kzg_commitments_root = kzgs.hash_tree_root()
-
-    return state.latest_execution_payload_header != header
-```
-
-#### Modified `validate_merge_block`
-`validate_merge_block` is modified to use the new `signed_execution_payload_header` message in the Beacon Block Body
-
-```python
-def validate_merge_block(block: BeaconBlock) -> None:
-    """
-    Check the parent PoW block of execution payload is a valid terminal PoW block.
-
-    Note: Unavailable PoW block(s) may later become available,
-    and a client software MAY delay a call to ``validate_merge_block``
-    until the PoW block(s) become available.
-    """
-    if TERMINAL_BLOCK_HASH != Hash32():
-        # If `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
-        assert compute_epoch_at_slot(block.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
-        assert block.body.signed_execution_payload_header.message.parent_block_hash == TERMINAL_BLOCK_HASH
-        return
-
-    # Modified in EIP-7732
-    pow_block = get_pow_block(block.body.signed_execution_payload_header.message.parent_block_hash)
-    # Check if `pow_block` is available
-    assert pow_block is not None
-    pow_parent = get_pow_block(pow_block.parent_hash)
-    # Check if `pow_parent` is available
-    assert pow_parent is not None
-    # Check if `pow_block` is a valid terminal PoW block
-    assert is_valid_terminal_pow_block(pow_block, pow_parent)
 ```