EIP-6988: keep proposer shuffling in state

.circleci/config.yml

@@ -168,6 +168,19 @@ jobs:
           command: make citest fork=eip6110
       - store_test_results:
           path: tests/core/pyspec/test-reports
+  test-eip6988:
+    docker:
+      - image: circleci/python:3.9
+    working_directory: ~/specs-repo
+    steps:
+      - restore_cache:
+          key: v3-specs-repo-{{ .Branch }}-{{ .Revision }}
+      - restore_pyspec_cached_venv
+      - run:
+          name: Run py-tests
+          command: make citest fork=eip6988
+      - store_test_results:
+          path: tests/core/pyspec/test-reports
   table_of_contents:
     docker:
       - image: circleci/node:10.16.3
@@ -291,6 +304,9 @@ workflows:
       - test-eip6110:
           requires:
             - install_pyspec_test
+      - test-eip6988:
+          requires:
+            - install_pyspec_test
       - table_of_contents
       - codespell
       - lint:

.github/workflows/run-tests.yml

@@ -83,7 +83,7 @@ jobs:
     needs: [preclear,lint,codespell,table_of_contents]
     strategy:
       matrix:
-        version: ["phase0", "altair", "bellatrix", "capella", "deneb", "eip6110"]
+        version: ["phase0", "altair", "bellatrix", "capella", "deneb", "eip6110", "eip6988"]
     steps:
       - name: Checkout this repo
         uses: actions/checkout@v3.2.0

.gitignore

@@ -21,6 +21,7 @@ tests/core/pyspec/eth2spec/bellatrix/
 tests/core/pyspec/eth2spec/capella/
 tests/core/pyspec/eth2spec/deneb/
 tests/core/pyspec/eth2spec/eip6110/
+tests/core/pyspec/eth2spec/eip6988/
 
 # coverage reports
 .htmlcov

Makefile

@@ -34,7 +34,7 @@ MARKDOWN_FILES = $(wildcard $(SPEC_DIR)/*/*.md) \
                  $(wildcard $(SPEC_DIR)/_features/*/*/*.md) \
                  $(wildcard $(SSZ_DIR)/*.md)
 
-ALL_EXECUTABLE_SPECS = phase0 altair bellatrix capella deneb eip6110
+ALL_EXECUTABLE_SPECS = phase0 altair bellatrix capella deneb eip6110 eip6988
 # The parameters for commands. Use `foreach` to avoid listing specs again.
 COVERAGE_SCOPE := $(foreach S,$(ALL_EXECUTABLE_SPECS), --cov=eth2spec.$S.$(TEST_PRESET_TYPE))
 PYLINT_SCOPE := $(foreach S,$(ALL_EXECUTABLE_SPECS), ./eth2spec/$S)

configs/mainnet.yaml

@@ -53,6 +53,9 @@ DENEB_FORK_EPOCH: 18446744073709551615
 # EIP6110
 EIP6110_FORK_VERSION: 0x05000000  # temporary stub
 EIP6110_FORK_EPOCH: 18446744073709551615
+# EIP6988
+EIP6988_FORK_VERSION: 0x04000000  # temporary stub
+EIP6988_FORK_EPOCH: 18446744073709551615
 
 
 # Time parameters

configs/minimal.yaml

@@ -52,6 +52,9 @@ DENEB_FORK_EPOCH: 18446744073709551615
 # EIP6110
 EIP6110_FORK_VERSION: 0x05000001
 EIP6110_FORK_EPOCH: 18446744073709551615
+# EIP6988
+EIP6988_FORK_VERSION: 0x04000001
+EIP6988_FORK_EPOCH: 18446744073709551615
 
 
 # Time parameters

setup.py

@@ -48,6 +48,7 @@ def installPackage(package: str):
 CAPELLA = 'capella'
 DENEB = 'deneb'
 EIP6110 = 'eip6110'
+EIP6988 = 'eip6988'
 
 
 # The helper functions that are used when defining constants
@@ -680,10 +681,22 @@ def imports(cls, preset_name: str):
 from eth2spec.deneb import {preset_name} as deneb
 '''
 
+#
+# EIP6988SpecBuilder
+#
+class EIP6988SpecBuilder(CapellaSpecBuilder):
+    fork: str = EIP6988
+
+    @classmethod
+    def imports(cls, preset_name: str):
+        return super().imports(preset_name) + f'''
+from eth2spec.capella import {preset_name} as capella
+'''
+
 
 spec_builders = {
     builder.fork: builder
-    for builder in (Phase0SpecBuilder, AltairSpecBuilder, BellatrixSpecBuilder, CapellaSpecBuilder, DenebSpecBuilder, EIP6110SpecBuilder)
+    for builder in (Phase0SpecBuilder, AltairSpecBuilder, BellatrixSpecBuilder, CapellaSpecBuilder, DenebSpecBuilder, EIP6110SpecBuilder, EIP6988SpecBuilder)
 }
 
 
@@ -982,14 +995,14 @@ def finalize_options(self):
         if len(self.md_doc_paths) == 0:
             print("no paths were specified, using default markdown file paths for pyspec"
                   " build (spec fork: %s)" % self.spec_fork)
-            if self.spec_fork in (PHASE0, ALTAIR, BELLATRIX, CAPELLA, DENEB, EIP6110):
+            if self.spec_fork in (PHASE0, ALTAIR, BELLATRIX, CAPELLA, DENEB, EIP6110, EIP6988):
                 self.md_doc_paths = """
                     specs/phase0/beacon-chain.md
                     specs/phase0/fork-choice.md
                     specs/phase0/validator.md
                     specs/phase0/weak-subjectivity.md
                 """
-            if self.spec_fork in (ALTAIR, BELLATRIX, CAPELLA, DENEB, EIP6110):
+            if self.spec_fork in (ALTAIR, BELLATRIX, CAPELLA, DENEB, EIP6110, EIP6988):
                 self.md_doc_paths += """
                     specs/altair/light-client/full-node.md
                     specs/altair/light-client/light-client.md
@@ -1001,7 +1014,7 @@ def finalize_options(self):
                     specs/altair/validator.md
                     specs/altair/p2p-interface.md
                 """
-            if self.spec_fork in (BELLATRIX, CAPELLA, DENEB, EIP6110):
+            if self.spec_fork in (BELLATRIX, CAPELLA, DENEB, EIP6110, EIP6988):
                 self.md_doc_paths += """
                     specs/bellatrix/beacon-chain.md
                     specs/bellatrix/fork.md
@@ -1010,7 +1023,7 @@ def finalize_options(self):
                     specs/bellatrix/p2p-interface.md
                     sync/optimistic.md
                 """
-            if self.spec_fork in (CAPELLA, DENEB, EIP6110):
+            if self.spec_fork in (CAPELLA, DENEB, EIP6110, EIP6988):
                 self.md_doc_paths += """
                     specs/capella/light-client/fork.md
                     specs/capella/light-client/full-node.md
@@ -1044,6 +1057,11 @@ def finalize_options(self):
                     specs/_features/eip6110/beacon-chain.md
                     specs/_features/eip6110/fork.md
                 """
+            if self.spec_fork == EIP6988:
+                self.md_doc_paths += """
+                    specs/_features/eip6988/beacon-chain.md
+                    specs/_features/eip6988/fork.md
+                """
             if len(self.md_doc_paths) == 0:
                 raise Exception('no markdown files specified, and spec fork "%s" is unknown', self.spec_fork)
 

specs/_features/eip6988/beacon-chain.md

@@ -0,0 +1,212 @@
+# EIP-6988 -- The Beacon Chain
+
+## 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)
+- [Helper functions](#helper-functions)
+  - [Misc](#misc)
+    - [Modified `compute_proposer_index`](#modified-compute_proposer_index)
+    - [Modified `get_beacon_proposer_index`](#modified-get_beacon_proposer_index)
+- [Testing](#testing)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+<!-- /TOC -->
+
+## Introduction
+
+This is the beacon chain specification of [EIP-6988](https://github.com/ethereum/EIPs/pull/6988).
+EIP-6988 modifies the protocol to prevent slashed validator from becoming a block proposer.
+
+*Note:* This specification is built upon [Capella](../../capella/beacon-chain.md) and is under active development.
+
+## Containers
+
+### Extended containers
+
+#### `BeaconState`
+
+```python
+class BeaconState(Container):
+    # 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
+    # Execution
+    latest_execution_payload_header: ExecutionPayloadHeader
+    # Withdrawals
+    next_withdrawal_index: WithdrawalIndex
+    next_withdrawal_validator_index: ValidatorIndex
+    # Deep history valid from Capella onwards
+    historical_summaries: List[HistoricalSummary, HISTORICAL_ROOTS_LIMIT]
+    # [New in EIP6988]
+    proposer_shuffling: Vector[ValidatorIndex, SLOTS_PER_EPOCH]
+```
+
+## Helper functions
+
+### Misc
+
+#### Modified `compute_proposer_index`
+
+*Note:* Disallowing slashed validator to become a proposer is the only modification of this function.
+
+```python
+def compute_proposer_index(state: BeaconState, indices: Sequence[ValidatorIndex], seed: Bytes32) -> ValidatorIndex:
+    """
+    Return from ``indices`` a random index sampled by effective balance.
+    """
+    assert len(indices) > 0
+    MAX_RANDOM_BYTE = 2**8 - 1
+    i = uint64(0)
+    total = uint64(len(indices))
+    while True:
+        candidate_index = indices[compute_shuffled_index(i % total, total, seed)]
+        random_byte = hash(seed + uint_to_bytes(uint64(i // 32)))[i % 32]
+        effective_balance = state.validators[candidate_index].effective_balance
+        # [Modified in EIP6988]
+        slashed = state.validators[candidate_index].slashed
+        if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte and not slashed:
+            return candidate_index
+        i += 1
+```
+
+#### Modified `get_beacon_proposer_index`
+
+*Note:* Modified to read proposer index from the state.
+
+```python
+def get_beacon_proposer_index(state: BeaconState) -> ValidatorIndex:
+    """
+    Return the beacon proposer index at the current slot.
+    """
+    return state.proposer_shuffling[state.slot]
+```
+
+## Epoch processing
+
+*Note*: The function `update_proposer_shuffling` is added in EIP-6988.
+
+```python
+def process_epoch(state: BeaconState) -> None:
+    process_justification_and_finalization(state)
+    process_inactivity_updates(state)
+    process_rewards_and_penalties(state)
+    process_registry_updates(state)
+    process_slashings(state)
+    process_eth1_data_reset(state)
+    process_effective_balance_updates(state)
+    process_slashings_reset(state)
+    process_randao_mixes_reset(state)
+    process_historical_summaries_update(state)
+    process_participation_flag_updates(state)
+    process_sync_committee_updates(state)
+    update_proposer_shuffling(state)  # [New in EIP-6988]
+```
+
+### New `update_proposer_shuffling`
+
+```python
+def update_proposer_shuffling(state: BeaconState) -> None:
+    epoch = get_current_epoch(state)
+    indices = get_active_validator_indices(state, epoch)
+    epoch_seed = get_seed(state, epoch, DOMAIN_BEACON_PROPOSER)
+
+    for slot in range(0, SLOTS_PER_EPOCH):
+        seed = hash(epoch_seed + uint_to_bytes(slot))
+        state.proposer_shuffling[slot] = compute_proposer_index(state, indices, seed)
+```
+
+## Testing
+
+*Note*: The function `initialize_beacon_state_from_eth1` is modified for pure EIP-6988 testing only.
+Modifications include:
+1. Use `EIP6988_FORK_VERSION` as the previous and current fork version.
+2. Utilize the EIP-6988 `BeaconBlockBody` when constructing the initial `latest_block_header`.
+3. Add `deposit_receipts_start_index` variable to the genesis state initialization.
+4. Initialize proposer shuffling by a call to `update_proposer_shuffling`.
+
+```python
+def initialize_beacon_state_from_eth1(eth1_block_hash: Hash32,
+                                      eth1_timestamp: uint64,
+                                      deposits: Sequence[Deposit],
+                                      execution_payload_header: ExecutionPayloadHeader=ExecutionPayloadHeader()
+                                      ) -> BeaconState:
+    fork = Fork(
+        previous_version=EIP6988_FORK_VERSION,  # [Modified in EIP6988] for testing only
+        current_version=EIP6988_FORK_VERSION,  # [Modified in EIP6988]
+        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())),
+        randao_mixes=[eth1_block_hash] * EPOCHS_PER_HISTORICAL_VECTOR,  # Seed RANDAO with Eth1 entropy
+    )
+
+    # 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)
+
+    # 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)
+
+    # Initialize the execution payload header
+    state.latest_execution_payload_header = execution_payload_header
+
+    # [New in EIP-6988]
+    # Initialize proposer shuffling
+    update_proposer_shuffling(state)
+
+    return state
+```