RANDAO reveal slashing, custody period staggering and integration of custody and RANDAO reveals

specs/core/0_beacon-chain.md

@@ -37,6 +37,7 @@
         - [Beacon operations](#beacon-operations)
             - [`ProposerSlashing`](#proposerslashing)
             - [`AttesterSlashing`](#attesterslashing)
+            - [`RandaoRevealSlashing`](#randaorevealslashing)
             - [`Attestation`](#attestation)
             - [`Deposit`](#deposit)
             - [`VoluntaryExit`](#voluntaryexit)
@@ -135,6 +136,7 @@
             - [Operations](#operations)
                 - [Proposer slashings](#proposer-slashings)
                 - [Attester slashings](#attester-slashings)
+                - [Randao reveal slashings](#randao-reveal-slashings)
                 - [Attestations](#attestations)
                 - [Deposits](#deposits)
                 - [Voluntary exits](#voluntary-exits)
@@ -267,6 +269,7 @@ Code snippets appearing in `this style` are to be interpreted as Python code.
 | - | - |
 | `MAX_PROPOSER_SLASHINGS` | `2**4` (= 16) |
 | `MAX_ATTESTER_SLASHINGS` | `2**0` (= 1) |
+| `MAX_RANDAO_REVEAL_SLASHINGS` | `2**0` (= 1) |
 | `MAX_ATTESTATIONS` | `2**7` (= 128) |
 | `MAX_DEPOSITS` | `2**4` (= 16) |
 | `MAX_VOLUNTARY_EXITS` | `2**4` (= 16) |
@@ -485,6 +488,18 @@ The types are defined topologically to aid in facilitating an executable version
 }
 ```
 
+#### `RandaoRevealSlashing`
+
+```python
+{
+    'revealer_index': ValidatorIndex,
+    'epoch': 'uint64',
+    'reveal': 'bytes96',
+    'masker_index': ValidatorIndex,
+    'mask': 'bytes32',
+}
+```
+
 #### `Attestation`
 
 ```python
@@ -557,6 +572,7 @@ The types are defined topologically to aid in facilitating an executable version
     'eth1_data': Eth1Data,
     'proposer_slashings': [ProposerSlashing],
     'attester_slashings': [AttesterSlashing],
+    'randao_reveal_slashings': [RandaoRevealSlashing],
     'attestations': [Attestation],
     'deposits': [Deposit],
     'voluntary_exits': [VoluntaryExit],
@@ -1512,6 +1528,7 @@ def get_empty_block() -> BeaconBlock:
             ),
             proposer_slashings=[],
             attester_slashings=[],
+            randao_reveal_slashings=[],
             attestations=[],
             deposits=[],
             voluntary_exits=[],
@@ -2310,6 +2327,44 @@ def process_attester_slashing(state: BeaconState,
         slash_validator(state, index)
 ```
 
+##### Randao reveal slashings
+
+Verify that `len(block.body.randao_reveal_slashings) <= MAX_RANDAO_REVEAL_SLASHINGS`.
+
+For each `randao_reveal_slashing` in `block.body.randao_reveal_slashings`, run the following function:
+
+```python
+def process_randao_reveal_slashing(state: BeaconState,
+                                   randao_reveal_slashing: RandaoRevealSlashing) -> None:
+    """
+    Process ``RandaoRevealSlashing`` operation.
+    Note that this function mutates ``state``.
+    """
+    revealer = state.validator_registry[randao_reveal_slashing.revealer_index]
+    masker = state.validator_registry[randao_reveal_slashing.masker_index]
+    pubkeys = [revealer.pubkey, masker.pubkey]
+    message_hashes = [
+        hash_tree_root(randao_reveal_slashing.epoch),
+        randao_reveal_slashing.mask,
+    ]
+
+    assert bls_verify_multiple(
+        pubkeys=pubkeys,
+        message_hashes=message_hashes,
+        signature=randao_reveal_slashing.reveal,
+        domain=get_domain(
+            fork=state.fork,
+            epoch=randao_reveal_slashing.epoch,
+            domain_type=DOMAIN_RANDAO,
+        ),
+    )
+
+    assert randao_reveal_slashing.epoch > get_current_epoch(state)
+    assert revealer.slashed is False
+
+    slash_validator(state, randao_reveal_slashing.revealer_index, randao_reveal_slashing.masker_index)
+```
+
 ##### Attestations
 
 Verify that `len(block.body.attestations) <= MAX_ATTESTATIONS`.

tests/phase0/block_processing/test_process_randao_reveal_slashing.py

@@ -0,0 +1,76 @@
+from copy import deepcopy
+import pytest
+
+import build.phase0.spec as spec
+from build.phase0.spec import (
+    get_balance,
+    get_current_epoch,
+    process_randao_reveal_slashing,
+)
+from tests.phase0.helpers import (
+    get_valid_randao_reveal_slashing,
+)
+
+# mark entire file as 'randao_reveal_slashings'
+pytestmark = pytest.mark.randao_reveal_slashings
+
+
+def run_randao_reveal_slashing_processing(state, randao_reveal_slashing, valid=True):
+    """
+    Run ``process_randao_reveal_slashing`` returning the pre and post state.
+    If ``valid == False``, run expecting ``AssertionError``
+    """
+    post_state = deepcopy(state)
+
+    if not valid:
+        with pytest.raises(AssertionError):
+            process_randao_reveal_slashing(post_state, randao_reveal_slashing)
+        return state, None
+
+    process_randao_reveal_slashing(post_state, randao_reveal_slashing)
+
+    slashed_validator = post_state.validator_registry[randao_reveal_slashing.revealer_index]
+    assert not slashed_validator.initiated_exit
+    assert slashed_validator.slashed
+    assert slashed_validator.exit_epoch < spec.FAR_FUTURE_EPOCH
+    assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH
+    # lost whistleblower reward
+    assert (
+        get_balance(post_state, randao_reveal_slashing.revealer_index) <
+        get_balance(state, randao_reveal_slashing.revealer_index)
+    )
+
+    return state, post_state
+
+
+def test_success(state):
+    randao_reveal_slashing = get_valid_randao_reveal_slashing(state)
+
+    pre_state, post_state = run_randao_reveal_slashing_processing(state, randao_reveal_slashing)
+
+    return pre_state, randao_reveal_slashing, post_state
+
+
+def test_reveal_from_current_epoch(state):
+    randao_reveal_slashing = get_valid_randao_reveal_slashing(state, get_current_epoch(state))
+
+    pre_state, post_state = run_randao_reveal_slashing_processing(state, randao_reveal_slashing, False)
+
+    return pre_state, randao_reveal_slashing, post_state
+
+
+def test_reveal_from_past_epoch(state):
+    randao_reveal_slashing = get_valid_randao_reveal_slashing(state, get_current_epoch(state) - 1)
+
+    pre_state, post_state = run_randao_reveal_slashing_processing(state, randao_reveal_slashing, False)
+
+    return pre_state, randao_reveal_slashing, post_state
+
+
+def test_revealer_is_slashed(state):
+    randao_reveal_slashing = get_valid_randao_reveal_slashing(state)
+    state.validator_registry[randao_reveal_slashing.revealer_index].slashed = True
+
+    pre_state, post_state = run_randao_reveal_slashing_processing(state, randao_reveal_slashing, False)
+
+    return pre_state, randao_reveal_slashing, post_state

tests/phase0/helpers.py

@@ -18,6 +18,7 @@
     DepositData,
     Eth1Data,
     ProposerSlashing,
+    RandaoRevealSlashing,
     VoluntaryExit,
     # functions
     convert_to_indexed,
@@ -31,6 +32,7 @@
     get_empty_block,
     get_epoch_start_slot,
     get_genesis_beacon_state,
+    hash_tree_root,
     slot_to_epoch,
     verify_merkle_branch,
     hash,
@@ -257,6 +259,42 @@ def get_valid_attester_slashing(state):
     )
 
 
+def get_valid_randao_reveal_slashing(state, epoch=None):
+    current_epoch = get_current_epoch(state)
+    revealer_index = get_active_validator_indices(state.validator_registry, current_epoch)[-1]
+    masker_index = get_active_validator_indices(state.validator_registry, current_epoch)[0]
+
+    if epoch is None:
+        epoch = current_epoch + 2
+
+    reveal = bls.sign(
+        message_hash=hash_tree_root(epoch),
+        privkey=pubkey_to_privkey[state.validator_registry[revealer_index].pubkey],
+        domain=get_domain(
+            fork=state.fork,
+            epoch=epoch,
+            domain_type=spec.DOMAIN_RANDAO,
+        ),
+    )
+    mask = bls.sign(
+        message_hash=hash_tree_root(epoch),
+        privkey=pubkey_to_privkey[state.validator_registry[masker_index].pubkey],
+        domain=get_domain(
+            fork=state.fork,
+            epoch=epoch,
+            domain_type=spec.DOMAIN_RANDAO,
+        ),
+    )
+
+    return RandaoRevealSlashing(
+        revealer_index=revealer_index,
+        epoch=epoch,
+        reveal=reveal,
+        masker_index=masker_index,
+        mask=mask,
+    )
+
+
 def get_valid_attestation(state, slot=None):
     if slot is None:
         slot = state.slot

utils/phase0/state_transition.py

@@ -46,6 +46,13 @@ def process_operations(state: BeaconState, block: BeaconBlock) -> None:
         spec.process_attester_slashing,
     )
 
+    process_operation_type(
+        state,
+        block.body.randao_reveal_slashings,
+        spec.MAX_RANDAO_REVEAL_SLASHINGS,
+        spec.process_randao_reveal_slashing,
+    )
+
     process_operation_type(
         state,
         block.body.attestations,