status-im
/
eth2.0-specs
mirror of https://github.com/status-im/eth2.0-specs.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #2319 from mkalinin/merge-terminology 

Apply new terminology to the merge spec
This commit is contained in:
Danny Ryan 2021-04-09 07:11:04 -05:00 committed by GitHub
parent 300832f81a ffe7d6db6a
commit f8c4977414
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 66 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
specs/merge/beacon-chain.md
View File

@ -20,17 +20,17 @@
- [`BeaconBlockBody`](#beaconblockbody)
- [`BeaconState`](#beaconstate)
- [New containers](#new-containers)
- [`ApplicationPayload`](#applicationpayload)
- [`ApplicationBlockHeader`](#applicationblockheader)
- [`ExecutionPayload`](#executionpayload)
- [`ExecutionPayloadHeader`](#executionpayloadheader)
- [Helper functions](#helper-functions)
- [Misc](#misc)
- [`is_transition_completed`](#is_transition_completed)
- [`is_transition_block`](#is_transition_block)
- [Block processing](#block-processing)
- [Application payload processing](#application-payload-processing)
- [`get_application_state`](#get_application_state)
- [`application_state_transition`](#application_state_transition)
- [`process_application_payload`](#process_application_payload)
- [Execution payload processing](#execution-payload-processing)
- [`get_execution_state`](#get_execution_state)
- [`execution_state_transition`](#execution_state_transition)
- [`process_execution_payload`](#process_execution_payload)
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
<!-- /TOC -->
@ -38,7 +38,7 @@
## Introduction
This is a patch implementing the executable beacon chain proposal.
It enshrines application-layer execution and validity as a first class citizen at the core of the beacon chain.
It enshrines transaction execution and validity as a first class citizen at the core of the beacon chain.
## Custom types
@ -73,32 +73,32 @@ order and append any additional fields to the end.
#### `BeaconBlockBody`
*Note*: `BeaconBlockBody` fields remain unchanged other than the addition of `application_payload`.
*Note*: `BeaconBlockBody` fields remain unchanged other than the addition of `execution_payload`.
```python
class BeaconBlockBody(phase0.BeaconBlockBody):
application_payload: ApplicationPayload # [New in Merge] application payload
execution_payload: ExecutionPayload # [New in Merge]
```
#### `BeaconState`
*Note*: `BeaconState` fields remain unchanged other than addition of `latest_application_block_header`.
*Note*: `BeaconState` fields remain unchanged other than addition of `latest_execution_payload_header`.
```python
class BeaconState(phase0.BeaconState):
# Application-layer
latest_application_block_header: ApplicationBlockHeader # [New in Merge]
# Execution-layer
latest_execution_payload_header: ExecutionPayloadHeader # [New in Merge]
```
### New containers
#### `ApplicationPayload`
#### `ExecutionPayload`
The application payload included in a `BeaconBlockBody`.
The execution payload included in a `BeaconBlockBody`.
```python
class ApplicationPayload(Container):
block_hash: Bytes32 # Hash of application block
class ExecutionPayload(Container):
block_hash: Bytes32 # Hash of execution block
parent_hash: Bytes32
coinbase: Bytes20
state_root: Bytes32
@ -110,15 +110,15 @@ class ApplicationPayload(Container):
transactions: List[OpaqueTransaction, MAX_APPLICATION_TRANSACTIONS]
```
#### `ApplicationBlockHeader`
#### `ExecutionPayloadHeader`
The application block header included in a `BeaconState`.
The execution payload header included in a `BeaconState`.
*Note:* Holds application payload data without transaction list.
*Note:* Holds execution payload data without transaction bodies.
```python
class ApplicationBlockHeader(Container):
block_hash: Bytes32 # Hash of application block
class ExecutionPayloadHeader(Container):
block_hash: Bytes32 # Hash of execution block
parent_hash: Bytes32
coinbase: Bytes20
state_root: Bytes32
@ -138,14 +138,14 @@ class ApplicationBlockHeader(Container):
```python
def is_transition_completed(state: BeaconState) -> boolean:
return state.latest_application_block_header.block_hash != Bytes32()
return state.latest_execution_payload_header != ExecutionPayloadHeader()
```
#### `is_transition_block`
```python
def is_transition_block(state: BeaconState, block_body: BeaconBlockBody) -> boolean:
return state.latest_application_block_header.block_hash == Bytes32() and block_body.application_payload.block_hash != Bytes32()
return not is_transition_completed(state) and block_body.execution_payload != ExecutionPayload()
```
### Block processing
@ -156,54 +156,56 @@ def process_block(state: BeaconState, block: BeaconBlock) -> None:
process_randao(state, block.body)
process_eth1_data(state, block.body)
process_operations(state, block.body)
process_application_payload(state, block.body) # [New in Merge]
process_execution_payload(state, block.body) # [New in Merge]
```
#### Application payload processing
#### Execution payload processing
##### `get_application_state`
##### `get_execution_state`
*Note*: `ApplicationState` class is an abstract class representing ethereum application state.
*Note*: `ExecutionState` class is an abstract class representing Ethereum execution state.
Let `get_application_state(application_state_root: Bytes32) -> ApplicationState` be the function that given the root hash returns a copy of ethereum application state.
Let `get_execution_state(execution_state_root: Bytes32) -> ExecutionState` be the function that given the root hash returns a copy of Ethereum execution state.
The body of the function is implementation dependent.
##### `application_state_transition`
##### `execution_state_transition`
Let `application_state_transition(application_state: ApplicationState, application_payload: ApplicationPayload) -> None` be the transition function of ethereum application state.
Let `execution_state_transition(execution_state: ExecutionState, execution_payload: ExecutionPayload) -> None` be the transition function of Ethereum execution state.
The body of the function is implementation dependent.
*Note*: `application_state_transition` must throw `AssertionError` if either the transition itself or one of the post-transition verifications has failed.
*Note*: `execution_state_transition` must throw `AssertionError` if either the transition itself or one of the pre or post conditions has failed.
##### `process_application_payload`
##### `process_execution_payload`
```python
def process_application_payload(state: BeaconState, body: BeaconBlockBody) -> None:
def process_execution_payload(state: BeaconState, body: BeaconBlockBody) -> None:
"""
Note: This function is designed to be able to be run in parallel with the other `process_block` sub-functions
"""
if not is_transition_completed(state):
assert body.application_payload == ApplicationPayload()
# Pre-merge, skip processing
if not is_transition_completed(state) and not is_transition_block(state, body):
return
if not is_transition_block(state, body):
assert body.application_payload.parent_hash == state.latest_application_block_header.block_hash
assert body.application_payload.number == state.latest_application_block_header.number + 1
execution_payload = body.execution_payload
application_state = get_application_state(state.latest_application_block_header.state_root)
application_state_transition(application_state, body.application_payload)
if is_transition_completed(state):
assert execution_payload.parent_hash == state.latest_execution_payload_header.block_hash
assert execution_payload.number == state.latest_execution_payload_header.number + 1
state.latest_application_block_header = ApplicationBlockHeader(
block_hash=application_payload.block_hash,
parent_hash=application_payload.parent_hash,
coinbase=application_payload.coinbase,
state_root=application_payload.state_root,
number=application_payload.number,
gas_limit=application_payload.gas_limit,
gas_used=application_payload.gas_used,
receipt_root=application_payload.receipt_root,
logs_bloom=application_payload.logs_bloom,
transactions_root=hash_tree_root(application_payload.transactions),
execution_state = get_execution_state(state.latest_execution_payload_header.state_root)
execution_state_transition(execution_state, execution_payload)
state.latest_execution_payload_header = ExecutionPayloadHeader(
block_hash=execution_payload.block_hash,
parent_hash=execution_payload.parent_hash,
coinbase=execution_payload.coinbase,
state_root=execution_payload.state_root,
number=execution_payload.number,
gas_limit=execution_payload.gas_limit,
gas_used=execution_payload.gas_used,
receipt_root=execution_payload.receipt_root,
logs_bloom=execution_payload.logs_bloom,
transactions_root=hash_tree_root(execution_payload.transactions),
)
```

2
specs/merge/fork-choice.md
View File

@ -77,7 +77,7 @@ def on_block(store: Store, signed_block: SignedBeaconBlock) -> None:
# [New in Merge]
if is_transition_block(pre_state, block.body):
# Delay consideration of block until PoW block is processed by the PoW node
pow_block = get_pow_block(block.body.application_payload.parent_hash)
pow_block = get_pow_block(block.body.execution_payload.parent_hash)
assert pow_block.is_processed
assert is_valid_transition_block(pow_block)

24
specs/merge/validator.md
View File

@ -15,9 +15,9 @@
- [Beacon chain responsibilities](#beacon-chain-responsibilities)
- [Block proposal](#block-proposal)
- [Constructing the `BeaconBlockBody`](#constructing-the-beaconblockbody)
- [Application Payload](#application-payload)
- [Execution Payload](#execution-payload)
- [`get_pow_chain_head`](#get_pow_chain_head)
- [`produce_application_payload`](#produce_application_payload)
- [`produce_execution_payload`](#produce_execution_payload)
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
<!-- /TOC -->
@ -34,37 +34,37 @@ All terminology, constants, functions, and protocol mechanics defined in the upd
## Beacon chain responsibilities
All validator responsibilities remain unchanged other than those noted below. Namely, the transition block handling and the addition of `ApplicationPayload`.
All validator responsibilities remain unchanged other than those noted below. Namely, the transition block handling and the addition of `ExecutionPayload`.
### Block proposal
#### Constructing the `BeaconBlockBody`
##### Application Payload
##### Execution Payload
###### `get_pow_chain_head`
Let `get_pow_chain_head() -> PowBlock` be the function that returns the head of the PoW chain. The body of the function is implementation specific.
###### `produce_application_payload`
###### `produce_execution_payload`
Let `produce_application_payload(parent_hash: Bytes32) -> ApplicationPayload` be the function that produces new instance of application payload.
Let `produce_execution_payload(parent_hash: Bytes32) -> ExecutionPayload` be the function that produces new instance of execution payload.
The body of this function is implementation dependent.
* Set `block.body.application_payload = get_application_payload(state)` where:
* Set `block.body.execution_payload = get_execution_payload(state)` where:
```python
def get_application_payload(state: BeaconState) -> ApplicationPayload:
def get_execution_payload(state: BeaconState) -> ExecutionPayload:
if not is_transition_completed(state):
pow_block = get_pow_chain_head()
if not is_valid_transition_block(pow_block):
# Pre-merge, empty payload
return ApplicationPayload()
return ExecutionPayload()
else:
# Signify merge via producing on top of the last PoW block
return produce_application_payload(pow_block.block_hash)
return produce_execution_payload(pow_block.block_hash)
# Post-merge, normal payload
application_parent_hash = state.latest_application_block_header.block_hash
return produce_application_payload(application_parent_hash)
execution_parent_hash = state.latest_execution_payload_header.block_hash
return produce_execution_payload(execution_parent_hash)
```