2021-12-22 07:46:18 +00:00
# Bellatrix -- The Beacon Chain
2021-03-11 12:33:36 +00:00
## Table of contents
<!-- TOC -->
<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE - RUN doctoc TO UPDATE -->
- [Introduction ](#introduction )
2021-03-29 18:56:43 +00:00
- [Custom types ](#custom-types )
2021-10-29 18:39:29 +00:00
- [Preset ](#preset )
2021-11-01 04:11:15 +00:00
- [Execution ](#execution )
2021-10-29 18:39:29 +00:00
- [Updated penalty values ](#updated-penalty-values )
2021-07-30 10:10:33 +00:00
- [Configuration ](#configuration )
2021-09-17 10:54:06 +00:00
- [Transition settings ](#transition-settings )
2021-03-11 12:33:36 +00:00
- [Containers ](#containers )
- [Extended containers ](#extended-containers )
- [`BeaconBlockBody` ](#beaconblockbody )
- [`BeaconState` ](#beaconstate )
- [New containers ](#new-containers )
2021-04-08 08:29:05 +00:00
- [`ExecutionPayload` ](#executionpayload )
- [`ExecutionPayloadHeader` ](#executionpayloadheader )
2021-03-11 12:33:36 +00:00
- [Helper functions ](#helper-functions )
2021-06-18 10:09:30 +00:00
- [Predicates ](#predicates )
2021-11-23 21:31:35 +00:00
- [`is_merge_transition_complete` ](#is_merge_transition_complete )
- [`is_merge_transition_block` ](#is_merge_transition_block )
2021-05-06 00:21:52 +00:00
- [`is_execution_enabled` ](#is_execution_enabled )
2021-06-18 10:09:30 +00:00
- [Misc ](#misc )
- [`compute_timestamp_at_slot` ](#compute_timestamp_at_slot )
2021-10-29 18:39:29 +00:00
- [Beacon state accessors ](#beacon-state-accessors )
- [Modified `get_inactivity_penalty_deltas` ](#modified-get_inactivity_penalty_deltas )
- [Beacon state mutators ](#beacon-state-mutators )
- [Modified `slash_validator` ](#modified-slash_validator )
2021-06-18 10:09:30 +00:00
- [Beacon chain state transition function ](#beacon-chain-state-transition-function )
- [Execution engine ](#execution-engine )
2023-05-15 16:27:00 +00:00
- [Request data ](#request-data )
- [`NewPayloadRequest` ](#newpayloadrequest )
- [Engine APIs ](#engine-apis )
2022-01-27 09:24:53 +00:00
- [`notify_new_payload` ](#notify_new_payload )
2021-03-11 12:33:36 +00:00
- [Block processing ](#block-processing )
2021-10-29 18:39:29 +00:00
- [Execution payload ](#execution-payload )
- [`process_execution_payload` ](#process_execution_payload )
- [Epoch processing ](#epoch-processing )
- [Slashings ](#slashings )
2021-06-18 10:09:30 +00:00
- [Testing ](#testing )
2021-03-11 12:33:36 +00:00
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
<!-- /TOC -->
## Introduction
2021-12-23 09:32:15 +00:00
This upgrade adds transaction execution to the beacon chain as part of Bellatrix upgrade.
2021-10-31 15:47:58 +00:00
Additionally, this upgrade introduces the following minor changes:
* Penalty parameter updates to their planned maximally punitive values
2021-03-11 12:33:36 +00:00
2021-03-26 19:20:23 +00:00
## Custom types
2021-06-18 10:09:30 +00:00
*Note*: The `Transaction` type is a stub which is not final.
2021-03-26 19:20:23 +00:00
| Name | SSZ equivalent | Description |
| - | - | - |
2021-10-19 21:46:18 +00:00
| `Transaction` | `ByteList[MAX_BYTES_PER_TRANSACTION]` | either a [typed transaction envelope ](https://eips.ethereum.org/EIPS/eip-2718#opaque-byte-array-rather-than-an-rlp-array ) or a legacy transaction|
2021-09-23 08:35:55 +00:00
| `ExecutionAddress` | `Bytes20` | Address of account on the execution layer |
2021-03-26 19:20:23 +00:00
2021-11-01 04:11:15 +00:00
## Preset
2021-03-11 12:33:36 +00:00
### Execution
| Name | Value |
| - | - |
2021-10-21 21:56:58 +00:00
| `MAX_BYTES_PER_TRANSACTION` | `uint64(2**30)` (= 1,073,741,824) |
| `MAX_TRANSACTIONS_PER_PAYLOAD` | `uint64(2**20)` (= 1,048,576) |
2021-03-24 10:30:29 +00:00
| `BYTES_PER_LOGS_BLOOM` | `uint64(2**8)` (= 256) |
2021-09-17 12:23:21 +00:00
| `MAX_EXTRA_DATA_BYTES` | `2**5` (= 32) |
2021-03-11 12:33:36 +00:00
2021-10-29 18:39:29 +00:00
### Updated penalty values
2021-12-22 07:46:18 +00:00
Bellatrix updates a few configuration values to move penalty parameters to their final, maximum security values.
2021-10-29 18:39:29 +00:00
*Note*: The spec does *not* override previous configuration values but instead creates new values and replaces usage throughout.
| Name | Value |
| - | - |
2021-12-22 07:46:18 +00:00
| `INACTIVITY_PENALTY_QUOTIENT_BELLATRIX` | `uint64(2**24)` (= 16,777,216) |
| `MIN_SLASHING_PENALTY_QUOTIENT_BELLATRIX` | `uint64(2**5)` (= 32) |
| `PROPORTIONAL_SLASHING_MULTIPLIER_BELLATRIX` | `uint64(3)` |
2021-10-29 18:39:29 +00:00
2021-07-30 10:10:33 +00:00
## Configuration
2021-09-17 10:20:25 +00:00
### Transition settings
| Name | Value |
| - | - |
2022-08-15 14:00:14 +00:00
| `TERMINAL_TOTAL_DIFFICULTY` | `58750000000000000000000` (Estimated: Sept 15, 2022)|
2021-10-18 19:38:08 +00:00
| `TERMINAL_BLOCK_HASH` | `Hash32()` |
2021-10-19 03:25:50 +00:00
| `TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH` | `FAR_FUTURE_EPOCH` |
2021-09-17 10:20:25 +00:00
2021-03-11 12:33:36 +00:00
## Containers
### Extended containers
#### `BeaconBlockBody`
```python
2021-07-22 14:36:41 +00:00
class BeaconBlockBody(Container):
randao_reveal: BLSSignature
eth1_data: Eth1Data # Eth1 data vote
graffiti: Bytes32 # Arbitrary data
# Operations
proposer_slashings: List[ProposerSlashing, MAX_PROPOSER_SLASHINGS]
attester_slashings: List[AttesterSlashing, MAX_ATTESTER_SLASHINGS]
attestations: List[Attestation, MAX_ATTESTATIONS]
deposits: List[Deposit, MAX_DEPOSITS]
voluntary_exits: List[SignedVoluntaryExit, MAX_VOLUNTARY_EXITS]
sync_aggregate: SyncAggregate
2021-06-18 10:09:30 +00:00
# Execution
2021-12-22 07:46:18 +00:00
execution_payload: ExecutionPayload # [New in Bellatrix]
2021-03-11 12:33:36 +00:00
```
#### `BeaconState`
```python
2021-07-22 18:01:50 +00:00
class BeaconState(Container):
2021-07-22 14:36:41 +00:00
# Versioning
genesis_time: uint64
genesis_validators_root: Root
slot: Slot
fork: Fork
# History
latest_block_header: BeaconBlockHeader
block_roots: Vector[Root, SLOTS_PER_HISTORICAL_ROOT]
state_roots: Vector[Root, SLOTS_PER_HISTORICAL_ROOT]
historical_roots: List[Root, HISTORICAL_ROOTS_LIMIT]
# Eth1
eth1_data: Eth1Data
eth1_data_votes: List[Eth1Data, EPOCHS_PER_ETH1_VOTING_PERIOD * SLOTS_PER_EPOCH]
eth1_deposit_index: uint64
# Registry
validators: List[Validator, VALIDATOR_REGISTRY_LIMIT]
balances: List[Gwei, VALIDATOR_REGISTRY_LIMIT]
# Randomness
randao_mixes: Vector[Bytes32, EPOCHS_PER_HISTORICAL_VECTOR]
# Slashings
slashings: Vector[Gwei, EPOCHS_PER_SLASHINGS_VECTOR] # Per-epoch sums of slashed effective balances
# Participation
previous_epoch_participation: List[ParticipationFlags, VALIDATOR_REGISTRY_LIMIT]
current_epoch_participation: List[ParticipationFlags, VALIDATOR_REGISTRY_LIMIT]
# Finality
justification_bits: Bitvector[JUSTIFICATION_BITS_LENGTH] # Bit set for every recent justified epoch
previous_justified_checkpoint: Checkpoint
current_justified_checkpoint: Checkpoint
finalized_checkpoint: Checkpoint
# Inactivity
inactivity_scores: List[uint64, VALIDATOR_REGISTRY_LIMIT]
# Sync
current_sync_committee: SyncCommittee
next_sync_committee: SyncCommittee
2021-06-18 10:09:30 +00:00
# Execution
2021-12-22 07:46:18 +00:00
latest_execution_payload_header: ExecutionPayloadHeader # [New in Bellatrix]
2021-03-11 12:33:36 +00:00
```
### New containers
2021-04-08 08:29:05 +00:00
#### `ExecutionPayload`
2021-03-11 12:33:36 +00:00
```python
2021-04-08 08:29:05 +00:00
class ExecutionPayload(Container):
2021-06-18 10:09:30 +00:00
# Execution block header fields
2021-04-08 08:48:03 +00:00
parent_hash: Hash32
2021-11-18 13:23:52 +00:00
fee_recipient: ExecutionAddress # 'beneficiary' in the yellow paper
2021-03-11 12:33:36 +00:00
state_root: Bytes32
2022-01-18 14:19:00 +00:00
receipts_root: Bytes32
2021-06-18 18:28:38 +00:00
logs_bloom: ByteVector[BYTES_PER_LOGS_BLOOM]
2022-02-22 11:16:33 +00:00
prev_randao: Bytes32 # 'difficulty' in the yellow paper
2021-06-18 10:09:30 +00:00
block_number: uint64 # 'number' in the yellow paper
2021-03-11 12:33:36 +00:00
gas_limit: uint64
gas_used: uint64
2021-04-13 13:08:47 +00:00
timestamp: uint64
2021-09-17 12:23:21 +00:00
extra_data: ByteList[MAX_EXTRA_DATA_BYTES]
2021-10-11 22:25:01 +00:00
base_fee_per_gas: uint256
2021-06-18 10:09:30 +00:00
# Extra payload fields
block_hash: Hash32 # Hash of execution block
transactions: List[Transaction, MAX_TRANSACTIONS_PER_PAYLOAD]
2021-03-11 12:33:36 +00:00
```
2021-04-08 08:29:05 +00:00
#### `ExecutionPayloadHeader`
2021-04-02 14:48:02 +00:00
```python
2021-04-08 08:29:05 +00:00
class ExecutionPayloadHeader(Container):
2021-06-18 10:09:30 +00:00
# Execution block header fields
2021-04-08 08:48:03 +00:00
parent_hash: Hash32
2021-11-18 13:23:52 +00:00
fee_recipient: ExecutionAddress
2021-04-02 14:48:02 +00:00
state_root: Bytes32
2022-01-17 18:05:01 +00:00
receipts_root: Bytes32
2021-04-02 14:48:02 +00:00
logs_bloom: ByteVector[BYTES_PER_LOGS_BLOOM]
2022-02-22 11:16:33 +00:00
prev_randao: Bytes32
2021-06-18 10:09:30 +00:00
block_number: uint64
2021-04-02 14:48:02 +00:00
gas_limit: uint64
gas_used: uint64
2021-04-13 13:08:47 +00:00
timestamp: uint64
2021-09-17 12:23:21 +00:00
extra_data: ByteList[MAX_EXTRA_DATA_BYTES]
2021-10-11 22:25:01 +00:00
base_fee_per_gas: uint256
2021-06-18 10:09:30 +00:00
# Extra payload fields
block_hash: Hash32 # Hash of execution block
2021-04-06 05:48:33 +00:00
transactions_root: Root
2021-04-02 14:48:02 +00:00
```
2021-06-18 10:09:30 +00:00
## Helper functions
2021-05-10 13:48:37 +00:00
2021-06-18 10:09:30 +00:00
### Predicates
2021-05-10 13:48:37 +00:00
2021-11-23 21:31:35 +00:00
#### `is_merge_transition_complete`
2021-05-10 13:48:37 +00:00
```python
2021-11-23 21:31:35 +00:00
def is_merge_transition_complete(state: BeaconState) -> bool:
2021-06-18 10:09:30 +00:00
return state.latest_execution_payload_header != ExecutionPayloadHeader()
2021-05-10 13:48:37 +00:00
```
2021-11-23 21:31:35 +00:00
#### `is_merge_transition_block`
2021-03-11 12:33:36 +00:00
2021-06-18 10:09:30 +00:00
```python
2021-11-23 21:31:35 +00:00
def is_merge_transition_block(state: BeaconState, body: BeaconBlockBody) -> bool:
return not is_merge_transition_complete(state) and body.execution_payload != ExecutionPayload()
2021-06-18 10:09:30 +00:00
```
2021-03-11 12:33:36 +00:00
2021-05-06 00:21:52 +00:00
#### `is_execution_enabled`
```python
2021-06-18 10:09:30 +00:00
def is_execution_enabled(state: BeaconState, body: BeaconBlockBody) -> bool:
2021-11-23 21:31:35 +00:00
return is_merge_transition_block(state, body) or is_merge_transition_complete(state)
2021-05-06 00:21:52 +00:00
```
2021-06-18 10:09:30 +00:00
### Misc
2021-03-11 12:33:36 +00:00
2021-06-18 10:09:30 +00:00
#### `compute_timestamp_at_slot`
2021-03-11 12:33:36 +00:00
2021-06-18 10:09:30 +00:00
*Note*: This function is unsafe with respect to overflows and underflows.
2021-03-11 12:33:36 +00:00
```python
2021-06-18 10:09:30 +00:00
def compute_timestamp_at_slot(state: BeaconState, slot: Slot) -> uint64:
slots_since_genesis = slot - GENESIS_SLOT
return uint64(state.genesis_time + slots_since_genesis * SECONDS_PER_SLOT)
2021-03-11 12:33:36 +00:00
```
2021-10-29 18:39:29 +00:00
### Beacon state accessors
#### Modified `get_inactivity_penalty_deltas`
2021-12-22 07:46:18 +00:00
*Note*: The function `get_inactivity_penalty_deltas` is modified to use `INACTIVITY_PENALTY_QUOTIENT_BELLATRIX` .
2021-10-29 18:39:29 +00:00
```python
def get_inactivity_penalty_deltas(state: BeaconState) -> Tuple[Sequence[Gwei], Sequence[Gwei]]:
"""
Return the inactivity penalty deltas by considering timely target participation flags and inactivity scores.
"""
rewards = [Gwei(0) for _ in range(len(state.validators))]
penalties = [Gwei(0) for _ in range(len(state.validators))]
previous_epoch = get_previous_epoch(state)
matching_target_indices = get_unslashed_participating_indices(state, TIMELY_TARGET_FLAG_INDEX, previous_epoch)
for index in get_eligible_validator_indices(state):
if index not in matching_target_indices:
penalty_numerator = state.validators[index].effective_balance * state.inactivity_scores[index]
2021-12-22 07:46:18 +00:00
# [Modified in Bellatrix]
penalty_denominator = INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_BELLATRIX
2021-10-29 18:39:29 +00:00
penalties[index] += Gwei(penalty_numerator // penalty_denominator)
return rewards, penalties
```
### Beacon state mutators
#### Modified `slash_validator`
2021-12-22 07:46:18 +00:00
*Note*: The function `slash_validator` is modified to use `MIN_SLASHING_PENALTY_QUOTIENT_BELLATRIX` .
2021-10-29 18:39:29 +00:00
```python
def slash_validator(state: BeaconState,
slashed_index: ValidatorIndex,
whistleblower_index: ValidatorIndex=None) -> None:
"""
Slash the validator with index ``slashed_index``.
"""
epoch = get_current_epoch(state)
initiate_validator_exit(state, slashed_index)
validator = state.validators[slashed_index]
validator.slashed = True
validator.withdrawable_epoch = max(validator.withdrawable_epoch, Epoch(epoch + EPOCHS_PER_SLASHINGS_VECTOR))
state.slashings[epoch % EPOCHS_PER_SLASHINGS_VECTOR] += validator.effective_balance
2021-12-22 07:46:18 +00:00
slashing_penalty = validator.effective_balance // MIN_SLASHING_PENALTY_QUOTIENT_BELLATRIX # [Modified in Bellatrix]
2021-10-31 15:47:58 +00:00
decrease_balance(state, slashed_index, slashing_penalty)
2021-10-29 18:39:29 +00:00
# Apply proposer and whistleblower rewards
proposer_index = get_beacon_proposer_index(state)
if whistleblower_index is None:
whistleblower_index = proposer_index
whistleblower_reward = Gwei(validator.effective_balance // WHISTLEBLOWER_REWARD_QUOTIENT)
proposer_reward = Gwei(whistleblower_reward * PROPOSER_WEIGHT // WEIGHT_DENOMINATOR)
increase_balance(state, proposer_index, proposer_reward)
increase_balance(state, whistleblower_index, Gwei(whistleblower_reward - proposer_reward))
```
2021-06-18 10:09:30 +00:00
## Beacon chain state transition function
2021-04-08 09:26:32 +00:00
2021-06-18 10:09:30 +00:00
### Execution engine
2023-05-15 16:27:00 +00:00
#### Request data
##### `NewPayloadRequest`
```python
@dataclass
class NewPayloadRequest(object):
execution_payload: ExecutionPayload
```
#### Engine APIs
2021-06-18 10:09:30 +00:00
The implementation-dependent `ExecutionEngine` protocol encapsulates the execution sub-system logic via:
* a state object `self.execution_state` of type `ExecutionState`
2022-01-27 09:24:53 +00:00
* a notification function `self.notify_new_payload` which may apply changes to the `self.execution_state`
2021-06-18 10:09:30 +00:00
2022-01-27 09:24:53 +00:00
*Note*: `notify_new_payload` is a function accessed through the `EXECUTION_ENGINE` module which instantiates the `ExecutionEngine` protocol.
2021-09-22 12:10:57 +00:00
2021-10-10 14:47:59 +00:00
The body of this function is implementation dependent.
The Engine API may be used to implement this and similarly defined functions via an external execution engine.
2021-09-22 12:10:57 +00:00
2022-01-27 09:24:53 +00:00
#### `notify_new_payload`
2021-04-14 06:53:30 +00:00
2021-04-08 09:26:32 +00:00
```python
2023-05-23 14:25:43 +00:00
def notify_new_payload(self: ExecutionEngine, execution_payload: ExecutionPayload) -> bool:
2021-06-18 10:09:30 +00:00
"""
2023-05-23 14:25:43 +00:00
Return ``True`` if and only if ``execution_payload`` is valid with respect to ``self.execution_state``.
2021-06-18 10:09:30 +00:00
"""
...
2021-04-08 09:26:32 +00:00
```
2021-03-11 12:33:36 +00:00
### Block processing
2021-09-01 14:59:16 +00:00
*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.
2021-09-01 12:42:58 +00:00
2021-03-11 12:33:36 +00:00
```python
def process_block(state: BeaconState, block: BeaconBlock) -> None:
process_block_header(state, block)
2021-09-01 12:42:58 +00:00
if is_execution_enabled(state, block.body):
2023-05-15 16:27:00 +00:00
process_execution_payload(state, block.body, EXECUTION_ENGINE) # [New in Bellatrix]
2021-03-11 12:33:36 +00:00
process_randao(state, block.body)
2021-03-20 13:21:11 +00:00
process_eth1_data(state, block.body)
2021-03-11 12:33:36 +00:00
process_operations(state, block.body)
2021-07-22 14:36:41 +00:00
process_sync_aggregate(state, block.body.sync_aggregate)
2021-03-11 12:33:36 +00:00
```
2021-10-29 18:39:29 +00:00
#### Execution payload
2021-03-11 12:33:36 +00:00
2021-10-29 18:39:29 +00:00
##### `process_execution_payload`
2021-03-11 12:33:36 +00:00
```python
2023-05-15 16:27:00 +00:00
def process_execution_payload(state: BeaconState, body: BeaconBlockBody, execution_engine: ExecutionEngine) -> None:
payload = body.execution_payload
2021-11-01 13:57:49 +00:00
# Verify consistency of the parent hash with respect to the previous execution payload header
2021-11-23 21:31:35 +00:00
if is_merge_transition_complete(state):
2021-06-18 10:09:30 +00:00
assert payload.parent_hash == state.latest_execution_payload_header.block_hash
2022-02-22 11:16:33 +00:00
# Verify prev_randao
assert payload.prev_randao == get_randao_mix(state, get_current_epoch(state))
2021-06-18 10:09:30 +00:00
# Verify timestamp
assert payload.timestamp == compute_timestamp_at_slot(state, state.slot)
# Verify the execution payload is valid
2023-05-23 14:25:43 +00:00
assert execution_engine.notify_new_payload(payload)
2021-07-07 12:44:22 +00:00
# Cache execution payload header
2021-04-08 08:29:05 +00:00
state.latest_execution_payload_header = ExecutionPayloadHeader(
2021-06-18 10:09:30 +00:00
parent_hash=payload.parent_hash,
2021-11-18 13:23:52 +00:00
fee_recipient=payload.fee_recipient,
2021-06-18 10:09:30 +00:00
state_root=payload.state_root,
2022-01-17 18:05:01 +00:00
receipts_root=payload.receipts_root,
2021-06-18 18:28:38 +00:00
logs_bloom=payload.logs_bloom,
2022-02-22 11:16:33 +00:00
prev_randao=payload.prev_randao,
2021-06-18 10:09:30 +00:00
block_number=payload.block_number,
gas_limit=payload.gas_limit,
gas_used=payload.gas_used,
timestamp=payload.timestamp,
2021-09-17 12:23:21 +00:00
extra_data=payload.extra_data,
2021-07-26 13:30:50 +00:00
base_fee_per_gas=payload.base_fee_per_gas,
2021-06-18 10:09:30 +00:00
block_hash=payload.block_hash,
transactions_root=hash_tree_root(payload.transactions),
2021-04-02 14:48:02 +00:00
)
2021-03-11 12:33:36 +00:00
```
2021-06-08 12:44:53 +00:00
2021-10-29 18:39:29 +00:00
### Epoch processing
#### Slashings
2021-12-22 07:46:18 +00:00
*Note*: The function `process_slashings` is modified to use `PROPORTIONAL_SLASHING_MULTIPLIER_BELLATRIX` .
2021-10-29 18:39:29 +00:00
```python
def process_slashings(state: BeaconState) -> None:
epoch = get_current_epoch(state)
total_balance = get_total_active_balance(state)
2021-10-31 15:47:58 +00:00
adjusted_total_slashing_balance = min(
2021-12-22 07:46:18 +00:00
sum(state.slashings) * PROPORTIONAL_SLASHING_MULTIPLIER_BELLATRIX, # [Modified in Bellatrix]
2021-10-31 15:47:58 +00:00
total_balance
)
2021-10-29 18:39:29 +00:00
for index, validator in enumerate(state.validators):
if validator.slashed and epoch + EPOCHS_PER_SLASHINGS_VECTOR // 2 == validator.withdrawable_epoch:
increment = EFFECTIVE_BALANCE_INCREMENT # Factored out from penalty numerator to avoid uint64 overflow
penalty_numerator = validator.effective_balance // increment * adjusted_total_slashing_balance
penalty = penalty_numerator // total_balance * increment
decrease_balance(state, ValidatorIndex(index), penalty)
```
2021-06-18 10:09:30 +00:00
## Testing
2021-06-08 12:44:53 +00:00
2021-12-22 07:46:18 +00:00
*Note*: The function `initialize_beacon_state_from_eth1` is modified for pure Bellatrix testing only.
2021-10-03 12:12:59 +00:00
Modifications include:
2022-07-18 06:45:00 +00:00
1. Use `BELLATRIX_FORK_VERSION` as the previous and current fork version.
2021-12-22 07:46:18 +00:00
2. Utilize the Bellatrix `BeaconBlockBody` when constructing the initial `latest_block_header` .
2021-10-03 12:12:59 +00:00
3. Initialize `latest_execution_payload_header` .
If `execution_payload_header == ExecutionPayloadHeader()` , then the Merge has not yet occurred.
2021-10-03 14:20:53 +00:00
Else, the Merge starts from genesis and the transition is incomplete.
2021-06-08 12:44:53 +00:00
```python
2021-11-23 15:20:26 +00:00
def initialize_beacon_state_from_eth1(eth1_block_hash: Hash32,
2021-06-08 12:44:53 +00:00
eth1_timestamp: uint64,
2021-10-03 12:12:59 +00:00
deposits: Sequence[Deposit],
2021-10-03 13:16:59 +00:00
execution_payload_header: ExecutionPayloadHeader=ExecutionPayloadHeader()
) -> BeaconState:
2021-06-08 12:44:53 +00:00
fork = Fork(
2021-12-22 07:46:18 +00:00
previous_version=BELLATRIX_FORK_VERSION, # [Modified in Bellatrix] for testing only
current_version=BELLATRIX_FORK_VERSION, # [Modified in Bellatrix]
2021-06-08 12:44:53 +00:00
epoch=GENESIS_EPOCH,
)
state = BeaconState(
genesis_time=eth1_timestamp + GENESIS_DELAY,
fork=fork,
eth1_data=Eth1Data(block_hash=eth1_block_hash, deposit_count=uint64(len(deposits))),
latest_block_header=BeaconBlockHeader(body_root=hash_tree_root(BeaconBlockBody())),
2021-06-22 08:23:26 +00:00
randao_mixes=[eth1_block_hash] * EPOCHS_PER_HISTORICAL_VECTOR, # Seed RANDAO with Eth1 entropy
2021-06-08 12:44:53 +00:00
)
# Process deposits
leaves = list(map(lambda deposit: deposit.data, deposits))
for index, deposit in enumerate(deposits):
deposit_data_list = List[DepositData, 2**DEPOSIT_CONTRACT_TREE_DEPTH](*leaves[:index + 1])
state.eth1_data.deposit_root = hash_tree_root(deposit_data_list)
process_deposit(state, deposit)
# Process activations
for index, validator in enumerate(state.validators):
balance = state.balances[index]
validator.effective_balance = min(balance - balance % EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE)
if validator.effective_balance == MAX_EFFECTIVE_BALANCE:
validator.activation_eligibility_epoch = GENESIS_EPOCH
validator.activation_epoch = GENESIS_EPOCH
# Set genesis validators root for domain separation and chain versioning
state.genesis_validators_root = hash_tree_root(state.validators)
2021-07-22 14:36:41 +00:00
# Fill in sync committees
# Note: A duplicate committee is assigned for the current and next committee at genesis
state.current_sync_committee = get_next_sync_committee(state)
state.next_sync_committee = get_next_sync_committee(state)
2021-12-22 07:46:18 +00:00
# [New in Bellatrix] Initialize the execution payload header
2021-10-03 13:16:59 +00:00
# If empty, will initialize a chain that has not yet gone through the Merge transition
2021-10-03 12:12:59 +00:00
state.latest_execution_payload_header = execution_payload_header
2021-06-08 12:44:53 +00:00
return state
```