diff --git a/README.md b/README.md
index 6ea9f1c14..d68c55cf3 100644
--- a/README.md
+++ b/README.md
@@ -11,6 +11,7 @@ This repo hosts the current eth2.0 specifications. Discussions about design rati
Core specifications for eth2.0 client validation can be found in [specs/core](specs/core). These are divided into phases. Each subsequent phase depends upon the prior. The current phases specified are:
* [Phase 0 -- The Beacon Chain](specs/core/0_beacon-chain.md)
+* [Phase 1 -- Custody game](specs/core/1_custody-game.md)
* [Phase 1 -- Shard Data Chains](specs/core/1_shard-data-chains.md)
Accompanying documents can be found in [specs](specs) and include
diff --git a/py_tests/phase0/block_processing/test_process_attester_slashing.py b/py_tests/phase0/block_processing/test_process_attester_slashing.py
new file mode 100644
index 000000000..b1f836a29
--- /dev/null
+++ b/py_tests/phase0/block_processing/test_process_attester_slashing.py
@@ -0,0 +1,115 @@
+from copy import deepcopy
+import pytest
+
+import pyspec.phase0.spec as spec
+from pyspec.phase0.spec import (
+ get_balance,
+ get_beacon_proposer_index,
+ process_attester_slashing,
+)
+from phase0.helpers import (
+ get_valid_attester_slashing,
+)
+
+# mark entire file as 'attester_slashing'
+pytestmark = pytest.mark.attester_slashings
+
+
+def run_attester_slashing_processing(state, attester_slashing, valid=True):
+ """
+ Run ``process_attester_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_attester_slashing(post_state, attester_slashing)
+ return state, None
+
+ process_attester_slashing(post_state, attester_slashing)
+
+ slashed_index = attester_slashing.attestation_1.custody_bit_0_indices[0]
+ slashed_validator = post_state.validator_registry[slashed_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, slashed_index) <
+ get_balance(state, slashed_index)
+ )
+ proposer_index = get_beacon_proposer_index(state, state.slot)
+ # gained whistleblower reward
+ assert (
+ get_balance(post_state, proposer_index) >
+ get_balance(state, proposer_index)
+ )
+
+ return state, post_state
+
+
+def test_success_double(state):
+ attester_slashing = get_valid_attester_slashing(state)
+
+ pre_state, post_state = run_attester_slashing_processing(state, attester_slashing)
+
+ return pre_state, attester_slashing, post_state
+
+
+def test_success_surround(state):
+ attester_slashing = get_valid_attester_slashing(state)
+
+ # set attestion1 to surround attestation 2
+ attester_slashing.attestation_1.data.source_epoch = attester_slashing.attestation_2.data.source_epoch - 1
+ attester_slashing.attestation_1.data.slot = attester_slashing.attestation_2.data.slot + spec.SLOTS_PER_EPOCH
+
+ pre_state, post_state = run_attester_slashing_processing(state, attester_slashing)
+
+ return pre_state, attester_slashing, post_state
+
+
+def test_same_data(state):
+ attester_slashing = get_valid_attester_slashing(state)
+
+ attester_slashing.attestation_1.data = attester_slashing.attestation_2.data
+
+ pre_state, post_state = run_attester_slashing_processing(state, attester_slashing, False)
+
+ return pre_state, attester_slashing, post_state
+
+
+def test_no_double_or_surround(state):
+ attester_slashing = get_valid_attester_slashing(state)
+
+ attester_slashing.attestation_1.data.slot += spec.SLOTS_PER_EPOCH
+
+ pre_state, post_state = run_attester_slashing_processing(state, attester_slashing, False)
+
+ return pre_state, attester_slashing, post_state
+
+
+def test_participants_already_slashed(state):
+ attester_slashing = get_valid_attester_slashing(state)
+
+ # set all indices to slashed
+ attestation_1 = attester_slashing.attestation_1
+ validator_indices = attestation_1.custody_bit_0_indices + attestation_1.custody_bit_1_indices
+ for index in validator_indices:
+ state.validator_registry[index].slashed = True
+
+ pre_state, post_state = run_attester_slashing_processing(state, attester_slashing, False)
+
+ return pre_state, attester_slashing, post_state
+
+
+def test_custody_bit_0_and_1(state):
+ attester_slashing = get_valid_attester_slashing(state)
+
+ attester_slashing.attestation_1.custody_bit_1_indices = (
+ attester_slashing.attestation_1.custody_bit_0_indices
+ )
+ pre_state, post_state = run_attester_slashing_processing(state, attester_slashing, False)
+
+ return pre_state, attester_slashing, post_state
diff --git a/py_tests/phase0/helpers.py b/py_tests/phase0/helpers.py
index 523202361..9ca05ba97 100644
--- a/py_tests/phase0/helpers.py
+++ b/py_tests/phase0/helpers.py
@@ -12,6 +12,7 @@ from pyspec.phase0.spec import (
Attestation,
AttestationData,
AttestationDataAndCustodyBit,
+ AttesterSlashing,
BeaconBlockHeader,
Deposit,
DepositData,
@@ -19,6 +20,7 @@ from pyspec.phase0.spec import (
ProposerSlashing,
VoluntaryExit,
# functions
+ convert_to_indexed,
get_active_validator_indices,
get_attestation_participants,
get_block_root,
@@ -244,6 +246,17 @@ def get_valid_proposer_slashing(state):
)
+def get_valid_attester_slashing(state):
+ attestation_1 = get_valid_attestation(state)
+ attestation_2 = deepcopy(attestation_1)
+ attestation_2.data.target_root = b'\x01'*32
+
+ return AttesterSlashing(
+ attestation_1=convert_to_indexed(state, attestation_1),
+ attestation_2=convert_to_indexed(state, attestation_2),
+ )
+
+
def get_valid_attestation(state, slot=None):
if slot is None:
slot = state.slot
diff --git a/py_tests/phase0/test_sanity.py b/py_tests/phase0/test_sanity.py
index 71f86d2a6..3ca390547 100644
--- a/py_tests/phase0/test_sanity.py
+++ b/py_tests/phase0/test_sanity.py
@@ -17,6 +17,7 @@ from pyspec.phase0.spec import (
# functions
get_active_validator_indices,
get_balance,
+ get_beacon_proposer_index,
get_block_root,
get_current_epoch,
get_domain,
@@ -40,6 +41,7 @@ from .helpers import (
build_empty_block_for_next_slot,
force_registry_change_at_next_epoch,
get_valid_attestation,
+ get_valid_attester_slashing,
get_valid_proposer_slashing,
privkeys,
pubkeys,
@@ -140,6 +142,39 @@ def test_proposer_slashing(state):
return state, [block], test_state
+def test_attester_slashing(state):
+ test_state = deepcopy(state)
+ attester_slashing = get_valid_attester_slashing(state)
+ validator_index = attester_slashing.attestation_1.custody_bit_0_indices[0]
+
+ #
+ # Add to state via block transition
+ #
+ block = build_empty_block_for_next_slot(test_state)
+ block.body.attester_slashings.append(attester_slashing)
+ state_transition(test_state, block)
+
+ assert not state.validator_registry[validator_index].initiated_exit
+ assert not state.validator_registry[validator_index].slashed
+
+ slashed_validator = test_state.validator_registry[validator_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(test_state, validator_index) < get_balance(state, validator_index)
+
+ proposer_index = get_beacon_proposer_index(test_state, test_state.slot)
+ # gained whistleblower reward
+ assert (
+ get_balance(test_state, proposer_index) >
+ get_balance(state, proposer_index)
+ )
+
+ return state, [block], test_state
+
+
def test_deposit_in_block(state):
pre_state = deepcopy(state)
test_deposit_data_leaves = [ZERO_HASH] * len(pre_state.validator_registry)
diff --git a/specs/core/0_beacon-chain.md b/specs/core/0_beacon-chain.md
index 991c35494..70c5b67f6 100644
--- a/specs/core/0_beacon-chain.md
+++ b/specs/core/0_beacon-chain.md
@@ -1,6 +1,6 @@
# Ethereum 2.0 Phase 0 -- The Beacon Chain
-**NOTICE**: This document is a work-in-progress for researchers and implementers. It reflects recent spec changes and takes precedence over the Python proof-of-concept implementation [[python-poc]](#ref-python-poc).
+**NOTICE**: This document is a work in progress for researchers and implementers. It reflects recent spec changes and takes precedence over the Python proof-of-concept implementation [[python-poc]](#ref-python-poc).
## Table of contents
@@ -18,7 +18,7 @@
- [Time parameters](#time-parameters)
- [State list lengths](#state-list-lengths)
- [Reward and penalty quotients](#reward-and-penalty-quotients)
- - [Max transactions per block](#max-transactions-per-block)
+ - [Max operations per block](#max-operations-per-block)
- [Signature domains](#signature-domains)
- [Data structures](#data-structures)
- [Misc dependencies](#misc-dependencies)
@@ -34,7 +34,7 @@
- [`Validator`](#validator)
- [`PendingAttestation`](#pendingattestation)
- [`HistoricalBatch`](#historicalbatch)
- - [Beacon transactions](#beacon-transactions)
+ - [Beacon operations](#beacon-operations)
- [`ProposerSlashing`](#proposerslashing)
- [`AttesterSlashing`](#attesterslashing)
- [`Attestation`](#attestation)
@@ -132,7 +132,7 @@
- [Block header](#block-header)
- [RANDAO](#randao)
- [Eth1 data](#eth1-data-1)
- - [Transactions](#transactions)
+ - [Operations](#operations)
- [Proposer slashings](#proposer-slashings)
- [Attester slashings](#attester-slashings)
- [Attestations](#attestations)
@@ -151,9 +151,9 @@
This document represents the specification for Phase 0 of Ethereum 2.0 -- The Beacon Chain.
-At the core of Ethereum 2.0 is a system chain called the "beacon chain". The beacon chain stores and manages the registry of [validators](#dfn-validator). In the initial deployment phases of Ethereum 2.0 the only mechanism to become a [validator](#dfn-validator) is to make a one-way ETH transaction to a deposit contract on Ethereum 1.0. Activation as a [validator](#dfn-validator) happens when Ethereum 1.0 deposit receipts are processed by the beacon chain, the activation balance is reached, and after a queuing process. Exit is either voluntary or done forcibly as a penalty for misbehavior.
+At the core of Ethereum 2.0 is a system chain called the "beacon chain". The beacon chain stores and manages the registry of [validators](#dfn-validator). In the initial deployment phases of Ethereum 2.0, the only mechanism to become a [validator](#dfn-validator) is to make a one-way ETH transaction to a deposit contract on Ethereum 1.0. Activation as a [validator](#dfn-validator) happens when Ethereum 1.0 deposit receipts are processed by the beacon chain, the activation balance is reached, and a queuing process is completed. Exit is either voluntary or done forcibly as a penalty for misbehavior.
-The primary source of load on the beacon chain is "attestations". Attestations are availability votes for a shard block, and simultaneously proof of stake votes for a beacon block. A sufficient number of attestations for the same shard block create a "crosslink", confirming the shard segment up to that shard block into the beacon chain. Crosslinks also serve as infrastructure for asynchronous cross-shard communication.
+The primary source of load on the beacon chain is "attestations". Attestations are simultaneously availability votes for a shard block and proof-of-stake votes for a beacon block. A sufficient number of attestations for the same shard block create a "crosslink", confirming the shard segment up to that shard block into the beacon chain. Crosslinks also serve as infrastructure for asynchronous cross-shard communication.
## Notation
@@ -161,20 +161,20 @@ Code snippets appearing in `this style` are to be interpreted as Python code.
## Terminology
-* **Validator** - a registered participant in the beacon chain. You can become one by sending Ether into the Ethereum 1.0 deposit contract.
+* **Validator** - a registered participant in the beacon chain. You can become one by sending ether into the Ethereum 1.0 deposit contract.
* **Active validator** - an active participant in the Ethereum 2.0 consensus invited to, among other things, propose and attest to blocks and vote for crosslinks.
* **Committee** - a (pseudo-) randomly sampled subset of [active validators](#dfn-active-validator). When a committee is referred to collectively, as in "this committee attests to X", this is assumed to mean "some subset of that committee that contains enough [validators](#dfn-validator) that the protocol recognizes it as representing the committee".
-* **Proposer** - the [validator](#dfn-validator) that creates a beacon chain block
+* **Proposer** - the [validator](#dfn-validator) that creates a beacon chain block.
* **Attester** - a [validator](#dfn-validator) that is part of a committee that needs to sign off on a beacon chain block while simultaneously creating a link (crosslink) to a recent shard block on a particular shard chain.
* **Beacon chain** - the central PoS chain that is the base of the sharding system.
* **Shard chain** - one of the chains on which user transactions take place and account data is stored.
* **Block root** - a 32-byte Merkle root of a beacon chain block or shard chain block. Previously called "block hash".
-* **Crosslink** - a set of signatures from a committee attesting to a block in a shard chain, which can be included into the beacon chain. Crosslinks are the main means by which the beacon chain "learns about" the updated state of shard chains.
-* **Slot** - a period during which one proposer has the ability to create a beacon chain block and some attesters have the ability to make attestations
-* **Epoch** - an aligned span of slots during which all [validators](#dfn-validator) get exactly one chance to make an attestation
-* **Finalized**, **justified** - see Casper FFG finalization [[casper-ffg]](#ref-casper-ffg)
-* **Withdrawal period** - the number of slots between a [validator](#dfn-validator) exit and the [validator](#dfn-validator) balance being withdrawable
-* **Genesis time** - the Unix time of the genesis beacon chain block at slot 0
+* **Crosslink** - a set of signatures from a committee attesting to a block in a shard chain that can be included into the beacon chain. Crosslinks are the main means by which the beacon chain "learns about" the updated state of shard chains.
+* **Slot** - a period during which one proposer has the ability to create a beacon chain block and some attesters have the ability to make attestations.
+* **Epoch** - an aligned span of slots during which all [validators](#dfn-validator) get exactly one chance to make an attestation.
+* **Finalized**, **justified** - see Casper FFG finalization [[casper-ffg]](#ref-casper-ffg).
+* **Withdrawal period** - the number of slots between a [validator](#dfn-validator) exit and the [validator](#dfn-validator) balance being withdrawable.
+* **Genesis time** - the Unix time of the genesis beacon chain block at slot 0.
## Constants
@@ -253,16 +253,15 @@ Code snippets appearing in `this style` are to be interpreted as Python code.
| Name | Value |
| - | - |
| `BASE_REWARD_QUOTIENT` | `2**5` (= 32) |
-| `WHISTLEBLOWER_REWARD_QUOTIENT` | `2**9` (= 512) |
-| `ATTESTATION_INCLUSION_REWARD_QUOTIENT` | `2**3` (= 8) |
+| `WHISTLEBLOWING_REWARD_QUOTIENT` | `2**9` (= 512) |
+| `PROPOSER_REWARD_QUOTIENT` | `2**3` (= 8) |
| `INACTIVITY_PENALTY_QUOTIENT` | `2**24` (= 16,777,216) |
| `MIN_PENALTY_QUOTIENT` | `2**5` (= 32) |
* The `BASE_REWARD_QUOTIENT` parameter dictates the per-epoch reward. It corresponds to ~2.54% annual interest assuming 10 million participating ETH in every epoch.
* The `INACTIVITY_PENALTY_QUOTIENT` equals `INVERSE_SQRT_E_DROP_TIME**2` where `INVERSE_SQRT_E_DROP_TIME := 2**12 epochs` (~18 days) is the time it takes the inactivity penalty to reduce the balance of non-participating [validators](#dfn-validator) to about `1/sqrt(e) ~= 60.6%`. Indeed, the balance retained by offline [validators](#dfn-validator) after `n` epochs is about `(1 - 1/INACTIVITY_PENALTY_QUOTIENT)**(n**2/2)` so after `INVERSE_SQRT_E_DROP_TIME` epochs it is roughly `(1 - 1/INACTIVITY_PENALTY_QUOTIENT)**(INACTIVITY_PENALTY_QUOTIENT/2) ~= 1/sqrt(e)`.
-
-### Max transactions per block
+### Max operations per block
| Name | Value |
| - | - |
@@ -460,7 +459,7 @@ The types are defined topologically to aid in facilitating an executable version
}
```
-### Beacon transactions
+### Beacon operations
#### `ProposerSlashing`
@@ -872,7 +871,7 @@ def compute_committee(validator_indices: List[ValidatorIndex],
]
```
-**Note**: this definition and the next few definitions are highly inefficient as algorithms as they re-calculate many sub-expressions. Production implementations are expected to appropriately use caching/memoization to avoid redoing work.
+**Note**: this definition and the next few definitions are highly inefficient as algorithms, as they re-calculate many sub-expressions. Production implementations are expected to appropriately use caching/memoization to avoid redoing work.
### `get_current_epoch_committee_count`
@@ -1187,6 +1186,9 @@ def verify_indexed_attestation(state: BeaconState, indexed_attestation: IndexedA
custody_bit_0_indices = indexed_attestation.custody_bit_0_indices
custody_bit_1_indices = indexed_attestation.custody_bit_1_indices
+ # ensure no duplicate indices across custody bits
+ assert len(set(custody_bit_0_indices).intersection(set(custody_bit_1_indices))) == 0
+
if len(custody_bit_1_indices) > 0: # [TO BE REMOVED IN PHASE 1]
return False
@@ -1398,21 +1400,25 @@ def exit_validator(state: BeaconState, index: ValidatorIndex) -> None:
#### `slash_validator`
```python
-def slash_validator(state: BeaconState, index: ValidatorIndex) -> None:
+def slash_validator(state: BeaconState, slashed_index: ValidatorIndex, whistleblower_index: ValidatorIndex=None) -> None:
"""
- Slash the validator with index ``index``.
+ Slash the validator with index ``slashed_index``.
Note that this function mutates ``state``.
"""
- validator = state.validator_registry[index]
- exit_validator(state, index)
- state.latest_slashed_balances[get_current_epoch(state) % LATEST_SLASHED_EXIT_LENGTH] += get_effective_balance(state, index)
+ exit_validator(state, slashed_index)
+ state.validator_registry[slashed_index].slashed = True
+ state.validator_registry[slashed_index].withdrawable_epoch = get_current_epoch(state) + LATEST_SLASHED_EXIT_LENGTH
+ slashed_balance = get_effective_balance(state, slashed_index)
+ state.latest_slashed_balances[get_current_epoch(state) % LATEST_SLASHED_EXIT_LENGTH] += slashed_balance
- whistleblower_index = get_beacon_proposer_index(state, state.slot)
- whistleblower_reward = get_effective_balance(state, index) // WHISTLEBLOWER_REWARD_QUOTIENT
- increase_balance(state, whistleblower_index, whistleblower_reward)
- decrease_balance(state, index, whistleblower_reward)
- validator.slashed = True
- validator.withdrawable_epoch = get_current_epoch(state) + LATEST_SLASHED_EXIT_LENGTH
+ proposer_index = get_beacon_proposer_index(state, state.slot)
+ if whistleblower_index is None:
+ whistleblower_index = proposer_index
+ whistleblowing_reward = slashed_balance // WHISTLEBLOWING_REWARD_QUOTIENT
+ proposer_reward = whistleblowing_reward // PROPOSER_REWARD_QUOTIENT
+ increase_balance(state, proposer_index, proposer_reward)
+ increase_balance(state, whistleblower_index, whistleblowing_reward - proposer_reward)
+ decrease_balance(state, slashed_index, whistleblowing_reward)
```
#### `prepare_validator_for_withdrawal`
@@ -1451,7 +1457,7 @@ Every Ethereum 1.0 deposit, of size between `MIN_DEPOSIT_AMOUNT` and `MAX_DEPOSI
### `Eth2Genesis` log
-When sufficiently many full deposits have been made the deposit contract emits the `Eth2Genesis` log. The beacon chain state may then be initialized by calling the `get_genesis_beacon_state` function (defined below) where:
+When a sufficient amount of full deposits have been made, the deposit contract emits the `Eth2Genesis` log. The beacon chain state may then be initialized by calling the `get_genesis_beacon_state` function (defined below) where:
* `genesis_time` equals `time` in the `Eth2Genesis` log
* `latest_eth1_data.deposit_root` equals `deposit_root` in the `Eth2Genesis` log
@@ -1582,13 +1588,13 @@ def get_genesis_beacon_state(genesis_validator_deposits: List[Deposit],
## Beacon chain processing
-The beacon chain is the system chain for Ethereum 2.0. The main responsibilities of the beacon chain are:
+The beacon chain is the system chain for Ethereum 2.0. The main responsibilities of the beacon chain are as follows:
* Store and maintain the registry of [validators](#dfn-validator)
* Process crosslinks (see above)
* Process its per-block consensus, as well as the finality gadget
-Processing the beacon chain is similar to processing the Ethereum 1.0 chain. Clients download and process blocks, and maintain a view of what is the current "canonical chain", terminating at the current "head". However, because of the beacon chain's relationship with Ethereum 1.0, and because it is a proof-of-stake chain, there are differences.
+Processing the beacon chain is similar to processing the Ethereum 1.0 chain. Clients download and process blocks and maintain a view of what is the current "canonical chain", terminating at the current "head". However, because of the beacon chain's relationship with Ethereum 1.0, and because it is a proof-of-stake chain, there are differences.
For a beacon chain block, `block`, to be processed by a node, the following conditions must be met:
@@ -1598,7 +1604,7 @@ For a beacon chain block, `block`, to be processed by a node, the following cond
If these conditions are not met, the client should delay processing the beacon block until the conditions are all satisfied.
-Beacon block production is significantly different because of the proof of stake mechanism. A client simply checks what it thinks is the canonical chain when it should create a block, and looks up what its slot number is; when the slot arrives, it either proposes or attests to a block as required. Note that this requires each node to have a clock that is roughly (i.e. within `SECONDS_PER_SLOT` seconds) synchronized with the other nodes.
+Beacon block production is significantly different because of the proof-of-stake mechanism. A client simply checks what it thinks is the canonical chain when it should create a block and looks up what its slot number is; when the slot arrives, it either proposes or attests to a block as required. Note that this requires each node to have a clock that is roughly (i.e. within `SECONDS_PER_SLOT` seconds) synchronized with the other nodes.
### Beacon chain fork choice rule
@@ -1660,7 +1666,7 @@ def lmd_ghost(store: Store, start_state: BeaconState, start_block: BeaconBlock)
## Beacon chain state transition function
-We now define the state transition function. At a high level the state transition is made up of four parts:
+We now define the state transition function. At a high level, the state transition is made up of four parts:
1. State caching, which happens at the start of every slot.
2. The per-epoch transitions, which happens at the start of the first slot of every epoch.
@@ -1668,7 +1674,7 @@ We now define the state transition function. At a high level the state transitio
4. The per-block transitions, which happens at every block.
Transition section notes:
-* The state caching, caches the state root of the previous slot.
+* The state caching caches the state root of the previous slot.
* The per-epoch transitions focus on the [validator](#dfn-validator) registry, including adjusting balances and activating and exiting [validators](#dfn-validator), as well as processing crosslinks and managing block justification/finalization.
* The per-slot transitions focus on the slot counter and block roots records updates.
* The per-block transitions generally focus on verifying aggregate signatures and saving temporary records relating to the per-block activity in the `BeaconState`.
@@ -1901,7 +1907,7 @@ def get_inactivity_penalty(state: BeaconState, index: ValidatorIndex, epochs_sin
return get_base_reward(state, index) + extra_penalty
```
-Note: When applying penalties in the following balance recalculations implementers should make sure the `uint64` does not underflow.
+Note: When applying penalties in the following balance recalculations, implementers should make sure the `uint64` does not underflow.
##### Justification and finalization
@@ -1951,7 +1957,7 @@ def get_justification_and_finalization_deltas(state: BeaconState) -> Tuple[List[
# Proposer bonus
if index in get_attesting_indices(state, state.previous_epoch_attestations):
proposer_index = get_beacon_proposer_index(state, inclusion_slot(state, index))
- rewards[proposer_index] += base_reward // ATTESTATION_INCLUSION_REWARD_QUOTIENT
+ rewards[proposer_index] += base_reward // PROPOSER_REWARD_QUOTIENT
# Take away max rewards if we're not finalizing
if epochs_since_finality > 4:
penalties[index] += base_reward * 4
@@ -2230,7 +2236,7 @@ def process_eth1_data(state: BeaconState, block: BeaconBlock) -> None:
state.eth1_data_votes.append(Eth1DataVote(eth1_data=block.body.eth1_data, vote_count=1))
```
-#### Transactions
+#### Operations
##### Proposer slashings
@@ -2242,7 +2248,7 @@ For each `proposer_slashing` in `block.body.proposer_slashings`, run the followi
def process_proposer_slashing(state: BeaconState,
proposer_slashing: ProposerSlashing) -> None:
"""
- Process ``ProposerSlashing`` transaction.
+ Process ``ProposerSlashing`` operation.
Note that this function mutates ``state``.
"""
proposer = state.validator_registry[proposer_slashing.proposer_index]
@@ -2273,7 +2279,7 @@ For each `attester_slashing` in `block.body.attester_slashings`, run the followi
def process_attester_slashing(state: BeaconState,
attester_slashing: AttesterSlashing) -> None:
"""
- Process ``AttesterSlashing`` transaction.
+ Process ``AttesterSlashing`` operation.
Note that this function mutates ``state``.
"""
attestation1 = attester_slashing.attestation_1
@@ -2287,10 +2293,12 @@ def process_attester_slashing(state: BeaconState,
assert verify_indexed_attestation(state, attestation1)
assert verify_indexed_attestation(state, attestation2)
+ attesting_indices_1 = attestation1.custody_bit_0_indices + attestation1.custody_bit_1_indices
+ attesting_indices_2 = attestation2.custody_bit_0_indices + attestation2.custody_bit_1_indices
slashable_indices = [
- index for index in attestation1.validator_indices
+ index for index in attesting_indices_1
if (
- index in attestation2.validator_indices and
+ index in attesting_indices_2 and
is_slashable_validator(state.validator_registry[index], get_current_epoch(state))
)
]
@@ -2308,7 +2316,7 @@ For each `attestation` in `block.body.attestations`, run the following function:
```python
def process_attestation(state: BeaconState, attestation: Attestation) -> None:
"""
- Process ``Attestation`` transaction.
+ Process ``Attestation`` operation.
Note that this function mutates ``state``.
"""
assert max(GENESIS_SLOT, state.slot - SLOTS_PER_EPOCH) <= attestation.data.slot
@@ -2363,7 +2371,7 @@ For each `exit` in `block.body.voluntary_exits`, run the following function:
```python
def process_voluntary_exit(state: BeaconState, exit: VoluntaryExit) -> None:
"""
- Process ``VoluntaryExit`` transaction.
+ Process ``VoluntaryExit`` operation.
Note that this function mutates ``state``.
"""
validator = state.validator_registry[exit.validator_index]
@@ -2399,7 +2407,7 @@ For each `transfer` in `block.body.transfers`, run the following function:
```python
def process_transfer(state: BeaconState, transfer: Transfer) -> None:
"""
- Process ``Transfer`` transaction.
+ Process ``Transfer`` operation.
Note that this function mutates ``state``.
"""
# Verify the amount and fee aren't individually too big (for anti-overflow purposes)
@@ -2446,7 +2454,7 @@ def verify_block_state_root(state: BeaconState, block: BeaconBlock) -> None:
# References
-This section is divided into Normative and Informative references. Normative references are those that must be read in order to implement this specification, while Informative references are merely that, information. An example of the former might be the details of a required consensus algorithm, and an example of the latter might be a pointer to research that demonstrates why a particular consensus algorithm might be better suited for inclusion in the standard than another.
+This section is divided into Normative and Informative references. Normative references are those that must be read in order to implement this specification, while Informative references are merely helpful information. An example of the former might be the details of a required consensus algorithm, and an example of the latter might be a pointer to research that demonstrates why a particular consensus algorithm might be better suited for inclusion in the standard than another.
## Normative
diff --git a/specs/core/1_custody-game.md b/specs/core/1_custody-game.md
new file mode 100644
index 000000000..e28536d34
--- /dev/null
+++ b/specs/core/1_custody-game.md
@@ -0,0 +1,499 @@
+# Ethereum 2.0 Phase 1 -- Custody Game
+
+**NOTICE**: This spec is a work-in-progress for researchers and implementers.
+
+## Table of contents
+
+
+
+- [Ethereum 2.0 Phase 1 -- Custody Game](#ethereum-20-phase-1----custody-game)
+ - [Table of contents](#table-of-contents)
+ - [Introduction](#introduction)
+ - [Terminology](#terminology)
+ - [Constants](#constants)
+ - [Misc](#misc)
+ - [Time parameters](#time-parameters)
+ - [Max operations per block](#max-operations-per-block)
+ - [Signature domains](#signature-domains)
+ - [Data structures](#data-structures)
+ - [Custody objects](#custody-objects)
+ - [`CustodyChunkChallenge`](#custodychunkchallenge)
+ - [`CustodyBitChallenge`](#custodybitchallenge)
+ - [`CustodyChunkChallengeRecord`](#custodychunkchallengerecord)
+ - [`CustodyBitChallengeRecord`](#custodybitchallengerecord)
+ - [`CustodyResponse`](#custodyresponse)
+ - [`CustodyKeyReveal`](#custodykeyreveal)
+ - [Phase 0 container updates](#phase-0-container-updates)
+ - [`Validator`](#validator)
+ - [`BeaconState`](#beaconstate)
+ - [`BeaconBlockBody`](#beaconblockbody)
+ - [Helpers](#helpers)
+ - [`get_crosslink_chunk_count`](#get_crosslink_chunk_count)
+ - [`get_custody_chunk_bit`](#get_custody_chunk_bit)
+ - [`epoch_to_custody_period`](#epoch_to_custody_period)
+ - [`verify_custody_key`](#verify_custody_key)
+ - [Per-block processing](#per-block-processing)
+ - [Operations](#operations)
+ - [Custody reveals](#custody-reveals)
+ - [Chunk challenges](#chunk-challenges)
+ - [Bit challenges](#bit-challenges)
+ - [Custody responses](#custody-responses)
+ - [Per-epoch processing](#per-epoch-processing)
+
+
+
+## Introduction
+
+This document details the beacon chain additions and changes in Phase 1 of Ethereum 2.0 to support the shard data custody game, building upon the [phase 0](0_beacon-chain.md) specification.
+
+## Terminology
+
+* **Custody game**:
+* **Custody period**:
+* **Custody chunk**:
+* **Custody chunk bit**:
+* **Custody chunk challenge**:
+* **Custody bit**:
+* **Custody bit challenge**:
+* **Custody key**:
+* **Custody key reveal**:
+* **Custody key mask**:
+* **Custody response**:
+* **Custody response deadline**:
+
+## Constants
+
+### Misc
+
+| Name | Value |
+| - | - |
+| `BYTES_PER_SHARD_BLOCK` | `2**14` (= 16,384) |
+| `BYTES_PER_CUSTODY_CHUNK` | `2**9` (= 512) |
+| `MINOR_REWARD_QUOTIENT` | `2**8` (= 256) |
+
+### Time parameters
+
+| Name | Value | Unit | Duration |
+| - | - | :-: | :-: |
+| `MAX_CHUNK_CHALLENGE_DELAY` | `2**11` (= 2,048) | epochs | ~9 days |
+| `EPOCHS_PER_CUSTODY_PERIOD` | `2**11` (= 2,048) | epochs | ~9 days |
+| `CUSTODY_RESPONSE_DEADLINE` | `2**14` (= 16,384) | epochs | ~73 days |
+
+### Max operations per block
+
+| Name | Value |
+| - | - |
+| `MAX_CUSTODY_KEY_REVEALS` | `2**4` (= 16) |
+| `MAX_CUSTODY_CHUNK_CHALLENGES` | `2**2` (= 4) |
+| `MAX_CUSTODY_BIT_CHALLENGES` | `2**2` (= 4) |
+| `MAX_CUSTODY_RESPONSES` | `2**5` (= 32) |
+
+### Signature domains
+
+| Name | Value |
+| - | - |
+| `DOMAIN_CUSTODY_KEY_REVEAL` | `6` |
+| `DOMAIN_CUSTODY_BIT_CHALLENGE` | `7` |
+
+## Data structures
+
+### Custody objects
+
+#### `CustodyChunkChallenge`
+
+```python
+{
+ 'responder_index': ValidatorIndex,
+ 'attestation': Attestation,
+ 'chunk_index': 'uint64',
+}
+```
+
+#### `CustodyBitChallenge`
+
+```python
+{
+ 'responder_index': ValidatorIndex,
+ 'attestation': Attestation,
+ 'challenger_index': ValidatorIndex,
+ 'responder_key': BLSSignature,
+ 'chunk_bits': Bitfield,
+ 'signature': BLSSignature,
+}
+```
+
+#### `CustodyChunkChallengeRecord`
+
+```python
+{
+ 'challenge_index': 'uint64',
+ 'challenger_index': ValidatorIndex,
+ 'responder_index': ValidatorIndex,
+ 'deadline': Epoch,
+ 'crosslink_data_root': Hash,
+ 'depth': 'uint64',
+ 'chunk_index': 'uint64',
+}
+```
+
+#### `CustodyBitChallengeRecord`
+
+```python
+{
+ 'challenge_index': 'uint64',
+ 'challenger_index': ValidatorIndex,
+ 'responder_index': ValidatorIndex,
+ 'deadline': Epoch,
+ 'crosslink_data_root': Hash,
+ 'chunk_bits': Bitfield,
+ 'responder_key': BLSSignature,
+}
+```
+
+#### `CustodyResponse`
+
+```python
+{
+ 'challenge_index': 'uint64',
+ 'chunk_index': 'uint64',
+ 'chunk': ['byte', BYTES_PER_CUSTODY_CHUNK],
+ 'branch': [Hash],
+}
+```
+
+#### `CustodyKeyReveal`
+
+```python
+{
+ 'revealer_index': ValidatorIndex,
+ 'period': 'uint64',
+ 'key': BLSSignature,
+ 'masker_index': ValidatorIndex,
+ 'mask': Hash,
+}
+```
+
+### Phase 0 container updates
+
+Add the following fields to the end of the specified container objects. Fields with underlying type `uint64` are initialized to `0` and list fields are initialized to `[]`.
+
+#### `Validator`
+
+```python
+ 'custody_reveal_index': 'uint64',
+ 'max_reveal_lateness': 'uint64',
+```
+
+#### `BeaconState`
+
+```python
+ 'custody_chunk_challenge_records': [CustodyChunkChallengeRecord],
+ 'custody_bit_challenge_records': [CustodyBitChallengeRecord],
+ 'custody_challenge_index': 'uint64',
+```
+
+#### `BeaconBlockBody`
+
+```python
+ 'custody_key_reveals': [CustodyKeyReveal],
+ 'custody_chunk_challenges': [CustodyChunkChallenge],
+ 'custody_bit_challenges': [CustodyBitChallenge],
+ 'custody_responses': [CustodyResponse],
+```
+
+## Helpers
+
+### `get_crosslink_chunk_count`
+
+```python
+def get_custody_chunk_count(attestation: Attestation) -> int:
+ crosslink_start_epoch = attestation.data.latest_crosslink.epoch
+ crosslink_end_epoch = slot_to_epoch(attestation.data.slot)
+ crosslink_crosslink_length = min(MAX_CROSSLINK_EPOCHS, end_epoch - start_epoch)
+ chunks_per_epoch = 2 * BYTES_PER_SHARD_BLOCK * SLOTS_PER_EPOCH // BYTES_PER_CUSTODY_CHUNK
+ return crosslink_crosslink_length * chunks_per_epoch
+```
+
+### `get_custody_chunk_bit`
+
+```python
+def get_custody_chunk_bit(key: BLSSignature, chunk: bytes) -> bool:
+ # TODO: Replace with something MPC-friendly, e.g. the Legendre symbol
+ return get_bitfield_bit(hash(challenge.responder_key + chunk), 0)
+```
+
+### `epoch_to_custody_period`
+
+```python
+def epoch_to_custody_period(epoch: Epoch) -> int:
+ return epoch // EPOCHS_PER_CUSTODY_PERIOD
+```
+
+### `verify_custody_key`
+
+```python
+def verify_custody_key(state: BeaconState, reveal: CustodyKeyReveal) -> bool:
+ # Case 1: non-masked non-punitive non-early reveal
+ pubkeys = [state.validator_registry[reveal.revealer_index].pubkey]
+ message_hashes = [hash_tree_root(reveal.period)]
+
+ # Case 2: masked punitive early reveal
+ # Masking prevents proposer stealing the whistleblower reward
+ # Secure under the aggregate extraction infeasibility assumption
+ # See pages 11-12 of https://crypto.stanford.edu/~dabo/pubs/papers/aggreg.pdf
+ if reveal.mask != ZERO_HASH:
+ pubkeys.append(state.validator_registry[reveal.masker_index].pubkey)
+ message_hashes.append(reveal.mask)
+
+ return bls_verify_multiple(
+ pubkeys=pubkeys,
+ message_hashes=message_hashes,
+ signature=reveal.key,
+ domain=get_domain(
+ fork=state.fork,
+ epoch=reveal.period * EPOCHS_PER_CUSTODY_PERIOD,
+ domain_type=DOMAIN_CUSTODY_KEY_REVEAL,
+ ),
+ )
+```
+
+## Per-block processing
+
+### Operations
+
+Add the following operations to the per-block processing, in order the given below and after all other operations in phase 0.
+
+#### Custody reveals
+
+Verify that `len(block.body.custody_key_reveals) <= MAX_CUSTODY_KEY_REVEALS`.
+
+For each `reveal` in `block.body.custody_key_reveals`, run the following function:
+
+```python
+def process_custody_reveal(state: BeaconState,
+ reveal: CustodyKeyReveal) -> None:
+ assert verify_custody_key(state, reveal)
+ revealer = state.validator_registry[reveal.revealer_index]
+ current_custody_period = epoch_to_custody_period(get_current_epoch(state))
+
+ # Case 1: non-masked non-punitive non-early reveal
+ if reveal.mask == ZERO_HASH:
+ assert reveal.period == epoch_to_custody_period(revealer.activation_epoch) + revealer.custody_reveal_index
+ # Revealer is active or exited
+ assert is_active_validator(revealer, get_current_epoch(state)) or revealer.exit_epoch > get_current_epoch(state)
+ revealer.custody_reveal_index += 1
+ revealer.max_reveal_lateness = max(revealer.max_reveal_lateness, current_custody_period - reveal.period)
+ proposer_index = get_beacon_proposer_index(state, state.slot)
+ increase_balance(state, proposer_index, base_reward(state, index) // MINOR_REWARD_QUOTIENT)
+
+ # Case 2: masked punitive early reveal
+ else:
+ assert reveal.period > current_custody_period
+ assert revealer.slashed is False
+ slash_validator(state, reveal.revealer_index, reveal.masker_index)
+```
+
+#### Chunk challenges
+
+Verify that `len(block.body.custody_chunk_challenges) <= MAX_CUSTODY_CHUNK_CHALLENGES`.
+
+For each `challenge` in `block.body.custody_chunk_challenges`, run the following function:
+
+```python
+def process_chunk_challenge(state: BeaconState,
+ challenge: CustodyChunkChallenge) -> None:
+ # Verify the attestation
+ assert verify_standalone_attestation(state, convert_to_standalone(state, challenge.attestation))
+ # Verify it is not too late to challenge
+ assert slot_to_epoch(challenge.attestation.data.slot) >= get_current_epoch(state) - MAX_CHUNK_CHALLENGE_DELAY
+ responder = state.validator_registry[challenge.responder_index]
+ assert responder.exit_epoch >= get_current_epoch(state) - MAX_CHUNK_CHALLENGE_DELAY
+ # Verify the responder participated in the attestation
+ attesters = get_attestation_participants(state, attestation.data, attestation.aggregation_bitfield)
+ assert challenge.responder_index in attesters
+ # Verify the challenge is not a duplicate
+ for record in state.custody_chunk_challenge_records:
+ assert (
+ record.crosslink_data_root != challenge.attestation.data.crosslink_data_root or
+ record.chunk_index != challenge.chunk_index
+ )
+ # Verify depth
+ depth = math.log2(next_power_of_two(get_custody_chunk_count(challenge.attestation)))
+ assert challenge.chunk_index < 2**depth
+ # Add new chunk challenge record
+ state.custody_chunk_challenge_records.append(CustodyChunkChallengeRecord(
+ challenge_index=state.custody_challenge_index,
+ challenger_index=get_beacon_proposer_index(state, state.slot),
+ responder_index=challenge.responder_index
+ deadline=get_current_epoch(state) + CUSTODY_RESPONSE_DEADLINE,
+ crosslink_data_root=challenge.attestation.data.crosslink_data_root,
+ depth=depth,
+ chunk_index=challenge.chunk_index,
+ ))
+ state.custody_challenge_index += 1
+ # Postpone responder withdrawability
+ responder.withdrawable_epoch = FAR_FUTURE_EPOCH
+```
+
+#### Bit challenges
+
+Verify that `len(block.body.custody_bit_challenges) <= MAX_CUSTODY_BIT_CHALLENGES`.
+
+For each `challenge` in `block.body.custody_bit_challenges`, run the following function:
+
+```python
+def process_bit_challenge(state: BeaconState,
+ challenge: CustodyBitChallenge) -> None:
+ # Verify challenge signature
+ challenger = state.validator_registry[challenge.challenger_index]
+ assert bls_verify(
+ pubkey=challenger.pubkey,
+ message_hash=signed_root(challenge),
+ signature=challenge.signature,
+ domain=get_domain(state, get_current_epoch(state), DOMAIN_CUSTODY_BIT_CHALLENGE),
+ )
+ # Verify the challenger is not slashed
+ assert challenger.slashed is False
+ # Verify the attestation
+ assert verify_standalone_attestation(state, convert_to_standalone(state, challenge.attestation))
+ # Verify the attestation is eligible for challenging
+ responder = state.validator_registry[challenge.responder_index]
+ min_challengeable_epoch = responder.exit_epoch - EPOCHS_PER_CUSTODY_PERIOD * (1 + responder.max_reveal_lateness)
+ assert min_challengeable_epoch <= slot_to_epoch(challenge.attestation.data.slot)
+ # Verify the responder participated in the attestation
+ attesters = get_attestation_participants(state, attestation.data, attestation.aggregation_bitfield)
+ assert challenge.responder_index in attesters
+ # A validator can be the challenger or responder for at most one challenge at a time
+ for record in state.custody_bit_challenge_records:
+ assert record.challenger_index != challenge.challenger_index
+ assert record.responder_index != challenge.responder_index
+ # Verify the responder key
+ assert verify_custody_key(state, CustodyKeyReveal(
+ revealer_index=challenge.responder_index,
+ period=epoch_to_custody_period(slot_to_epoch(attestation.data.slot)),
+ key=challenge.responder_key,
+ masker_index=0,
+ mask=ZERO_HASH,
+ ))
+ # Verify the chunk count
+ chunk_count = get_custody_chunk_count(challenge.attestation)
+ assert verify_bitfield(challenge.chunk_bits, chunk_count)
+ # Verify the xor of the chunk bits does not equal the custody bit
+ chunk_bits_xor = 0b0
+ for i in range(chunk_count):
+ chunk_bits_xor ^ get_bitfield_bit(challenge.chunk_bits, i)
+ custody_bit = get_bitfield_bit(attestation.custody_bitfield, attesters.index(responder_index))
+ assert custody_bit != chunk_bits_xor
+ # Add new bit challenge record
+ state.custody_bit_challenge_records.append(CustodyBitChallengeRecord(
+ challenge_index=state.custody_challenge_index,
+ challenger_index=challenge.challenger_index,
+ responder_index=challenge.responder_index,
+ deadline=get_current_epoch(state) + CUSTODY_RESPONSE_DEADLINE
+ crosslink_data_root=challenge.attestation.crosslink_data_root,
+ chunk_bits=challenge.chunk_bits,
+ responder_key=challenge.responder_key,
+ ))
+ state.custody_challenge_index += 1
+ # Postpone responder withdrawability
+ responder.withdrawable_epoch = FAR_FUTURE_EPOCH
+```
+
+#### Custody responses
+
+Verify that `len(block.body.custody_responses) <= MAX_CUSTODY_RESPONSES`.
+
+For each `response` in `block.body.custody_responses`, run the following function:
+
+```python
+def process_custody_response(state: BeaconState,
+ response: CustodyResponse) -> None:
+ chunk_challenge = next(record for record in state.custody_chunk_challenge_records if record.challenge_index == response.challenge_index, None)
+ if chunk_challenge is not None:
+ return process_chunk_challenge_response(state, response, chunk_challenge)
+
+ bit_challenge = next(record for record in state.custody_bit_challenge_records if record.challenge_index == response.challenge_index, None)
+ if bit_challenge is not None:
+ return process_bit_challenge_response(state, response, bit_challenge)
+
+ assert False
+```
+
+```python
+def process_chunk_challenge_response(state: BeaconState,
+ response: CustodyResponse,
+ challenge: CustodyChunkChallengeRecord) -> None:
+ # Verify chunk index
+ assert response.chunk_index == challenge.chunk_index
+ # Verify the chunk matches the crosslink data root
+ assert verify_merkle_branch(
+ leaf=hash_tree_root(response.chunk),
+ branch=response.branch,
+ depth=challenge.depth,
+ index=response.chunk_index,
+ root=challenge.crosslink_data_root,
+ )
+ # Clear the challenge
+ state.custody_chunk_challenge_records.remove(challenge)
+ # Reward the proposer
+ proposer_index = get_beacon_proposer_index(state, state.slot)
+ increase_balance(state, proposer_index, base_reward(state, index) // MINOR_REWARD_QUOTIENT)
+```
+
+```python
+def process_bit_challenge_response(state: BeaconState,
+ response: CustodyResponse,
+ challenge: CustodyBitChallengeRecord) -> None:
+ # Verify chunk index
+ assert response.chunk_index < len(challenge.chunk_bits)
+ # Verify the chunk matches the crosslink data root
+ assert verify_merkle_branch(
+ leaf=hash_tree_root(response.chunk),
+ branch=response.branch,
+ depth=math.log2(next_power_of_two(len(challenge.chunk_bits))),
+ index=response.chunk_index,
+ root=challenge.crosslink_data_root,
+ )
+ # Verify the chunk bit does not match the challenge chunk bit
+ assert get_custody_chunk_bit(challenge.responder_key, response.chunk) != get_bitfield_bit(challenge.chunk_bits, response.chunk_index)
+ # Clear the challenge
+ state.custody_bit_challenge_records.remove(challenge)
+ # Slash challenger
+ slash_validator(state, challenge.challenger_index, challenge.responder_index)
+```
+
+## Per-epoch processing
+
+Run `process_challenge_deadlines(state)` immediately after `process_ejections(state)`:
+
+```python
+def process_challenge_deadlines(state: BeaconState) -> None:
+ for challenge in state.custody_chunk_challenge_records:
+ if get_current_epoch(state) > challenge.deadline:
+ slash_validator(state, challenge.responder_index, challenge.challenger_index)
+ state.custody_chunk_challenge_records.remove(challenge)
+
+ for challenge in state.custody_bit_challenge_records:
+ if get_current_epoch(state) > challenge.deadline:
+ slash_validator(state, challenge.responder_index, challenge.challenger_index)
+ state.custody_bit_challenge_records.remove(challenge)
+```
+
+In `process_penalties_and_exits`, change the definition of `eligible` to the following (note that it is not a pure function because `state` is declared in the surrounding scope):
+
+```python
+def eligible(index):
+ validator = state.validator_registry[index]
+ # Cannot exit if there are still open chunk challenges
+ if len([record for record in state.custody_chunk_challenge_records if record.responder_index == index]) > 0:
+ return False
+ # Cannot exit if you have not revealed all of your custody keys
+ elif epoch_to_custody_period(revealer.activation_epoch) + validator.custody_reveal_index <= epoch_to_custody_period(validator.exit_epoch):
+ return False
+ # Cannot exit if you already have
+ elif validator.withdrawable_epoch < FAR_FUTURE_EPOCH:
+ return False
+ # Return minimum time
+ else:
+ return current_epoch >= validator.exit_epoch + MIN_VALIDATOR_WITHDRAWAL_EPOCHS
+```
diff --git a/specs/core/1_shard-data-chains.md b/specs/core/1_shard-data-chains.md
index 92cee4d19..8f2d12a91 100644
--- a/specs/core/1_shard-data-chains.md
+++ b/specs/core/1_shard-data-chains.md
@@ -1,157 +1,143 @@
# Ethereum 2.0 Phase 1 -- Shard Data Chains
-**NOTICE**: This document is a work-in-progress for researchers and implementers. It reflects recent spec changes and takes precedence over the [Python proof-of-concept implementation](https://github.com/ethereum/beacon_chain).
+**NOTICE**: This document is a work-in-progress for researchers and implementers.
-At the current stage, Phase 1, while fundamentally feature-complete, is still subject to change. Development teams with spare resources may consider starting on the "Shard chains and crosslink data" section; at least basic properties, such as the fact that a shard block can get created every slot and is dependent on both a parent block in the same shard and a beacon chain block at or before that same slot, are unlikely to change, though details are likely to undergo similar kinds of changes to what Phase 0 has undergone since the start of the year.
-
-## Table of contents
+## Table of Contents
-- [Ethereum 2.0 Phase 1 -- Shard Data Chains](#ethereum-20-phase-1----shard-data-chains)
- - [Table of contents](#table-of-contents)
- - [Introduction](#introduction)
- - [Terminology](#terminology)
- - [Constants](#constants)
- - [Misc](#misc)
- - [Time parameters](#time-parameters)
- - [Max operations per block](#max-operations-per-block)
- - [Signature domains](#signature-domains)
-- [Shard chains and crosslink data](#shard-chains-and-crosslink-data)
- - [Helper functions](#helper-functions)
- - [`get_shuffled_committee`](#get_shuffled_committee)
- - [`get_persistent_committee`](#get_persistent_committee)
- - [`get_shard_proposer_index`](#get_shard_proposer_index)
- - [Data Structures](#data-structures)
- - [Shard chain blocks](#shard-chain-blocks)
- - [Shard block processing](#shard-block-processing)
- - [Verifying shard block data](#verifying-shard-block-data)
- - [Verifying a crosslink](#verifying-a-crosslink)
- - [Shard block fork choice rule](#shard-block-fork-choice-rule)
-- [Updates to the beacon chain](#updates-to-the-beacon-chain)
+- [Ethereum 2.0 Phase 1 -- Shards Data Chains](#ethereum-20-phase-1----shard-data-chains)
+ - [Table of Contents](#table-of-contents)
+ - [Introduction](#introduction)
+ - [Constants](#constants)
+ - [Misc](#misc)
+ - [Time parameters](#time-parameters)
+ - [Signature domains](#signature-domains)
- [Data structures](#data-structures)
- - [`Validator`](#validator)
- - [`BeaconBlockBody`](#beaconblockbody)
- - [`BeaconState`](#beaconstate)
- - [`BranchChallenge`](#branchchallenge)
- - [`BranchResponse`](#branchresponse)
- - [`BranchChallengeRecord`](#branchchallengerecord)
- - [`InteractiveCustodyChallengeRecord`](#interactivecustodychallengerecord)
- - [`InteractiveCustodyChallengeInitiation`](#interactivecustodychallengeinitiation)
- - [`InteractiveCustodyChallengeResponse`](#interactivecustodychallengeresponse)
- - [`InteractiveCustodyChallengeContinuation`](#interactivecustodychallengecontinuation)
- - [`SubkeyReveal`](#subkeyreveal)
- - [Helpers](#helpers)
- - [`get_branch_challenge_record_by_id`](#get_branch_challenge_record_by_id)
- - [`get_custody_challenge_record_by_id`](#get_custody_challenge_record_by_id)
- - [`get_attestation_merkle_depth`](#get_attestation_merkle_depth)
- - [`epoch_to_custody_period`](#epoch_to_custody_period)
- - [`slot_to_custody_period`](#slot_to_custody_period)
- - [`get_current_custody_period`](#get_current_custody_period)
- - [`verify_custody_subkey_reveal`](#verify_custody_subkey_reveal)
- - [`verify_signed_challenge_message`](#verify_signed_challenge_message)
- - [`penalize_validator`](#penalize_validator)
- - [Per-slot processing](#per-slot-processing)
- - [Operations](#operations)
- - [Branch challenges](#branch-challenges)
- - [Branch responses](#branch-responses)
- - [Subkey reveals](#subkey-reveals)
- - [Interactive custody challenge initiations](#interactive-custody-challenge-initiations)
- - [Interactive custody challenge responses](#interactive-custody-challenge-responses)
- - [Interactive custody challenge continuations](#interactive-custody-challenge-continuations)
- - [Per-epoch processing](#per-epoch-processing)
- - [One-time phase 1 initiation transition](#one-time-phase-1-initiation-transition)
+ - [`ShardBlockBody`](#shardblockbody)
+ - [`ShardBlock`](#shardblock)
+ - [`ShardBlockHeader`](#shardblockheader)
+ - [`ShardAttestation`](#shardattestation)
+ - [Helper functions](#helper-functions)
+ - [`get_period_committee`](#get_period_committee)
+ - [`get_persistent_committee`](#get_persistent_committee)
+ - [`get_shard_proposer_index`](#get_shard_proposer_index)
+ - [`get_shard_header`](#get_shard_header)
+ - [`verify_shard_attestation_signature`](#verify_shard_attestation_signature)
+ - [`compute_crosslink_data_root`](#compute_crosslink_data_root)
+ - [Object validity](#object-validity)
+ - [Shard blocks](#shard-blocks)
+ - [Shard attestations](#shard-attestations)
+ - [Beacon attestations](#beacon-attestations)
+ - [Shard fork choice rule](#shard-fork-choice-rule)
-### Introduction
+## Introduction
-This document represents the specification for Phase 1 of Ethereum 2.0 -- Shard Data Chains. Phase 1 depends on the implementation of [Phase 0 -- The Beacon Chain](0_beacon-chain.md).
+This document describes the shard data layer and the shard fork choice rule in Phase 1 of Ethereum 2.0.
-Ethereum 2.0 consists of a central beacon chain along with `SHARD_COUNT` shard chains. Phase 1 is primarily concerned with the construction, validity, and consensus on the _data_ of these shard chains. Phase 1 does not specify shard chain state execution or account balances. This is left for future phases.
+## Constants
-### Terminology
+### Misc
-### Constants
+| Name | Value |
+| - | - |
+| `BYTES_PER_SHARD_BLOCK_BODY` | `2**14` (= 16,384) |
+| `MAX_SHARD_ATTESTIONS` | `2**4` (= 16) |
+| `PHASE_1_GENESIS_EPOCH` | **TBD** |
+| `PHASE_1_GENESIS_SLOT` | get_epoch_start_slot(PHASE_1_GENESIS_EPOCH) |
-Phase 1 depends upon all of the constants defined in [Phase 0](0_beacon-chain.md#constants) in addition to the following:
-
-#### Misc
-
-| Name | Value | Unit |
-|-------------------------------|------------------|--------|
-| `SHARD_CHUNK_SIZE` | 2**5 (= 32) | bytes |
-| `SHARD_BLOCK_SIZE` | 2**14 (= 16,384) | bytes |
-| `MINOR_REWARD_QUOTIENT` | 2**8 (= 256) | |
-| `MAX_POC_RESPONSE_DEPTH` | 5 | |
-| `ZERO_PUBKEY` | int_to_bytes48(0)| |
-| `VALIDATOR_NULL` | 2**64 - 1 | |
-
-#### Time parameters
+### Time parameters
| Name | Value | Unit | Duration |
| - | - | :-: | :-: |
-| `CROSSLINK_LOOKBACK` | 2**5 (= 32) | slots | 3.2 minutes |
-| `MAX_BRANCH_CHALLENGE_DELAY` | 2**11 (= 2,048) | epochs | 9 days |
-| `CUSTODY_PERIOD_LENGTH` | 2**11 (= 2,048) | epochs | 9 days |
-| `PERSISTENT_COMMITTEE_PERIOD` | 2**11 (= 2,048) | epochs | 9 days |
-| `CHALLENGE_RESPONSE_DEADLINE` | 2**14 (= 16,384) | epochs | 73 days |
+| `CROSSLINK_LOOKBACK` | 2**0 (= 1) | epochs | 6.2 minutes |
+| `PERSISTENT_COMMITTEE_PERIOD` | 2**11 (= 2,048) | epochs | ~9 days |
-#### Max operations per block
+### Signature domains
-| Name | Value |
-|----------------------------------------------------|---------------|
-| `MAX_BRANCH_CHALLENGES` | 2**2 (= 4) |
-| `MAX_BRANCH_RESPONSES` | 2**4 (= 16) |
-| `MAX_EARLY_SUBKEY_REVEALS` | 2**4 (= 16) |
-| `MAX_INTERACTIVE_CUSTODY_CHALLENGE_INITIATIONS` | 2 |
-| `MAX_INTERACTIVE_CUSTODY_CHALLENGE_RESPONSES` | 16 |
-| `MAX_INTERACTIVE_CUSTODY_CHALLENGE_CONTINUTATIONS` | 16 |
+| Name | Value |
+| - | - |
+| `DOMAIN_SHARD_PROPOSER` | `128` |
+| `DOMAIN_SHARD_ATTESTER` | `129` |
-#### Signature domains
+## Data structures
-| Name | Value |
-|------------------------------|-----------------|
-| `DOMAIN_SHARD_PROPOSER` | 129 |
-| `DOMAIN_SHARD_ATTESTER` | 130 |
-| `DOMAIN_CUSTODY_SUBKEY` | 131 |
-| `DOMAIN_CUSTODY_INTERACTIVE` | 132 |
+### `ShardBlockBody`
-# Shard chains and crosslink data
+```python
+['byte', BYTES_PER_SHARD_BLOCK_BODY]
+```
+
+### `ShardBlock`
+
+```python
+{
+ 'slot': Slot,
+ 'shard': Shard,
+ 'beacon_chain_root': Hash,
+ 'previous_block_root': Hash,
+ 'data': ShardBlockBody,
+ 'state_root': Hash,
+ 'attestations': [ShardAttestation],
+ 'signature': BLSSignature,
+}
+```
+
+### `ShardBlockHeader`
+
+```python
+{
+ 'slot': Slot,
+ 'shard': Shard,
+ 'beacon_chain_root': Hash,
+ 'previous_block_root': Hash,
+ 'body_root': Hash,
+ 'state_root': Hash,
+ 'attestations': [ShardAttestation],
+ 'signature': BLSSignature,
+}
+```
+
+### `ShardAttestation`
+
+```python
+{
+ 'data': {
+ 'slot': Slot,
+ 'shard': Shard,
+ 'shard_block_root': Hash,
+ },
+ 'aggregation_bitfield': Bitfield,
+ 'aggregate_signature': BLSSignature,
+}
+```
## Helper functions
-#### `get_shuffled_committee`
+### `get_period_committee`
```python
-def get_shuffled_committee(state: BeaconState,
- shard: Shard,
- committee_start_epoch: Epoch,
- index: int,
- committee_count: int) -> List[ValidatorIndex]:
+def get_period_committee(state: BeaconState,
+ shard: Shard,
+ committee_start_epoch: Epoch,
+ index: int,
+ committee_count: int) -> List[ValidatorIndex]:
"""
- Return shuffled committee.
+ Return committee for a period. Used to construct persistent committees.
"""
active_validator_indices = get_active_validator_indices(state.validator_registry, committee_start_epoch)
- length = len(active_validator_indices)
seed = generate_seed(state, committee_start_epoch)
- start_offset = get_split_offset(
- length,
- SHARD_COUNT * committee_count,
- shard * committee_count + index,
+ return compute_committee(
+ validator_indices=active_validator_indices,
+ seed=seed,
+ index=shard * committee_count + index,
+ total_committees=SHARD_COUNT * committee_count,
)
- end_offset = get_split_offset(
- length,
- SHARD_COUNT * committee_count,
- shard * committee_count + index + 1,
- )
- return [
- active_validator_indices[get_permuted_index(i, length, seed)]
- for i in range(start_offset, end_offset)
- ]
```
-#### `get_persistent_committee`
+### `get_persistent_committee`
```python
def get_persistent_committee(state: BeaconState,
@@ -160,7 +146,6 @@ def get_persistent_committee(state: BeaconState,
"""
Return the persistent committee for the given ``shard`` at the given ``slot``.
"""
-
earlier_start_epoch = epoch - (epoch % PERSISTENT_COMMITTEE_PERIOD) - PERSISTENT_COMMITTEE_PERIOD * 2
later_start_epoch = epoch - (epoch % PERSISTENT_COMMITTEE_PERIOD) - PERSISTENT_COMMITTEE_PERIOD
@@ -172,14 +157,11 @@ def get_persistent_committee(state: BeaconState,
) + 1
index = slot % committee_count
- earlier_committee = get_shuffled_committee(state, shard, earlier_start_epoch, index, committee_count)
- later_committee = get_shuffled_committee(state, shard, later_start_epoch, index, committee_count)
+ earlier_committee = get_period_committee(state, shard, earlier_start_epoch, index, committee_count)
+ later_committee = get_period_committee(state, shard, later_start_epoch, index, committee_count)
def get_switchover_epoch(index):
- return (
- bytes_to_int(hash(earlier_seed + bytes3(index))[0:8]) %
- PERSISTENT_COMMITTEE_PERIOD
- )
+ return bytes_to_int(hash(earlier_seed + bytes3(index))[0:8]) % PERSISTENT_COMMITTEE_PERIOD
# Take not-yet-cycled-out validators from earlier committee and already-cycled-in validators from
# later committee; return a sorted list of the union of the two, deduplicated
@@ -189,723 +171,232 @@ def get_persistent_committee(state: BeaconState,
)))
```
-#### `get_shard_proposer_index`
+### `get_shard_proposer_index`
```python
def get_shard_proposer_index(state: BeaconState,
shard: Shard,
slot: Slot) -> ValidatorIndex:
- seed = hash(
- state.current_shuffling_seed +
- int_to_bytes8(shard) +
- int_to_bytes8(slot)
- )
+ # Randomly shift persistent committee
persistent_committee = get_persistent_committee(state, shard, slot)
- # Default proposer
- index = bytes_to_int(seed[0:8]) % len(persistent_committee)
- # If default proposer exits, try the other proposers in order; if all are exited
- # return None (ie. no block can be proposed)
- validators_to_try = persistent_committee[index:] + persistent_committee[:index]
- for index in validators_to_try:
+ seed = hash(state.current_shuffling_seed + int_to_bytes8(shard) + int_to_bytes8(slot))
+ random_index = bytes_to_int(seed[0:8]) % len(persistent_committee)
+ persistent_committee = persistent_committee[random_index:] + persistent_committee[:random_index]
+
+ # Search for an active proposer
+ for index in persistent_committee:
if is_active_validator(state.validator_registry[index], get_current_epoch(state)):
return index
+
+ # No block can be proposed if no validator is active
return None
```
-## Data Structures
-
-### Shard chain blocks
-
-A `ShardBlock` object has the following fields:
+### `get_shard_header`
```python
-{
- # Slot number
- 'slot': 'uint64',
- # What shard is it on
- 'shard_id': 'uint64',
- # Parent block's root
- 'parent_root': 'bytes32',
- # Beacon chain block
- 'beacon_chain_ref': 'bytes32',
- # Merkle root of data
- 'data_root': 'bytes32'
- # State root (placeholder for now)
- 'state_root': 'bytes32',
- # Block signature
- 'signature': 'bytes96',
- # Attestation
- 'participation_bitfield': 'bytes',
- 'aggregate_signature': 'bytes96',
-}
+def get_shard_header(block: ShardBlock) -> ShardBlockHeader:
+ return ShardBlockHeader(
+ slot: block.slot,
+ shard: block.shard,
+ beacon_chain_root: block.beacon_chain_root,
+ previous_block_root: block.previous_block_root,
+ body_root: hash_tree_root(block.body),
+ state_root: block.state_root,
+ attestations: block.attestations,
+ signature: block.signature,
+ )
```
-## Shard block processing
-
-For a `shard_block` on a shard to be processed by a node, the following conditions must be met:
-
-* The `ShardBlock` pointed to by `shard_block.parent_root` has already been processed and accepted
-* The signature for the block from the _proposer_ (see below for definition) of that block is included along with the block in the network message object
-
-To validate a block header on shard `shard_block.shard_id`, compute as follows:
-
-* Verify that `shard_block.beacon_chain_ref` is the hash of a block in the (canonical) beacon chain with slot less than or equal to `slot`.
-* Verify that `shard_block.beacon_chain_ref` is equal to or a descendant of the `shard_block.beacon_chain_ref` specified in the `ShardBlock` pointed to by `shard_block.parent_root`.
-* Let `state` be the state of the beacon chain block referred to by `shard_block.beacon_chain_ref`.
-* Let `persistent_committee = get_persistent_committee(state, shard_block.shard_id, shard_block.slot)`.
-* Assert `verify_bitfield(shard_block.participation_bitfield, len(persistent_committee))`
-* For every `i in range(len(persistent_committee))` where `is_active_validator(state.validator_registry[persistent_committee[i]], get_current_epoch(state))` returns `False`, verify that `get_bitfield_bit(shard_block.participation_bitfield, i) == 0`
-* Let `proposer_index = get_shard_proposer_index(state, shard_block.shard_id, shard_block.slot)`.
-* Verify that `proposer_index` is not `None`.
-* Let `msg` be the `shard_block` but with `shard_block.signature` set to `[0, 0]`.
-* Verify that `bls_verify(pubkey=validators[proposer_index].pubkey, message_hash=hash(msg), signature=shard_block.signature, domain=get_domain(state, slot_to_epoch(shard_block.slot), DOMAIN_SHARD_PROPOSER))` passes.
-* Let `group_public_key = bls_aggregate_pubkeys([state.validator_registry[index].pubkey for i, index in enumerate(persistent_committee) if get_bitfield_bit(shard_block.participation_bitfield, i) is True])`.
-* Verify that `bls_verify(pubkey=group_public_key, message_hash=shard_block.parent_root, sig=shard_block.aggregate_signature, domain=get_domain(state, slot_to_epoch(shard_block.slot), DOMAIN_SHARD_ATTESTER))` passes.
-
-### Verifying shard block data
-
-At network layer, we expect a shard block header to be broadcast along with its `block_body`.
-
-* Verify that `len(block_body) == SHARD_BLOCK_SIZE`
-* Verify that `merkle_root(block_body)` equals the `data_root` in the header.
-
-### Verifying a crosslink
-
-A node should sign a crosslink only if the following conditions hold. **If a node has the capability to perform the required level of verification, it should NOT follow chains on which a crosslink for which these conditions do NOT hold has been included, or a sufficient number of signatures have been included that during the next state recalculation, a crosslink will be registered.**
-
-First, the conditions must recursively apply to the crosslink referenced in `last_crosslink_root` for the same shard (unless `last_crosslink_root` equals zero, in which case we are at the genesis).
-
-Second, we verify the `shard_chain_commitment`.
-* Let `start_slot = state.latest_crosslinks[shard].epoch * SLOTS_PER_EPOCH + SLOTS_PER_EPOCH - CROSSLINK_LOOKBACK`.
-* Let `end_slot = attestation.data.slot - attestation.data.slot % SLOTS_PER_EPOCH - CROSSLINK_LOOKBACK`.
-* Let `length = end_slot - start_slot`, `headers[0] .... headers[length-1]` be the serialized block headers in the canonical shard chain from the verifer's point of view (note that this implies that `headers` and `bodies` have been checked for validity).
-* Let `bodies[0] ... bodies[length-1]` be the bodies of the blocks.
-* Note: If there is a missing slot, then the header and body are the same as that of the block at the most recent slot that has a block.
-
-We define two helpers:
+### `verify_shard_attestation_signature`
```python
-def pad_to_power_of_2(values: List[bytes]) -> List[bytes]:
- zero_shard_block = b'\x00' * SHARD_BLOCK_SIZE
- while not is_power_of_two(len(values)):
- values = values + [zero_shard_block]
- return values
+def verify_shard_attestation_signature(state: BeaconState,
+ attestation: ShardAttestation) -> None:
+ data = attestation.data
+ persistent_committee = get_persistent_committee(state, data.shard, data.slot)
+ assert verify_bitfield(attestation.aggregation_bitfield, len(persistent_committee))
+ pubkeys = []
+ for i, index in enumerate(persistent_committee):
+ if get_bitfield_bit(attestation.aggregation_bitfield, i) == 0b1
+ validator = state.validator_registry[index]
+ assert is_active_validator(validator, get_current_epoch(state))
+ pubkeys.append(validator.pubkey)
+ assert bls_verify(
+ pubkey=bls_aggregate_pubkeys(pubkeys),
+ message_hash=data.shard_block_root,
+ signature=attestation.aggregate_signature,
+ domain=get_domain(state, slot_to_epoch(data.slot), DOMAIN_SHARD_ATTESTER)
+ )
```
-```python
-def merkle_root_of_bytes(data: bytes) -> bytes:
- return merkle_root([data[i:i + 32] for i in range(0, len(data), 32)])
-```
-
-We define the function for computing the commitment as follows:
+### `compute_crosslink_data_root`
```python
-def compute_commitment(headers: List[ShardBlock], bodies: List[bytes]) -> Bytes32:
+def compute_crosslink_data_root(blocks: List[ShardBlock]) -> Hash:
+ def is_power_of_two(value: int) -> bool:
+ return (value > 0) and (value & (value - 1) == 0)
+
+ def pad_to_power_of_2(values: List[bytes]) -> List[bytes]:
+ while not is_power_of_two(len(values)):
+ values += [b'\x00' * BYTES_PER_SHARD_BLOCK_BODY]
+ return values
+
+ def merkle_root_of_bytes(data: bytes) -> bytes:
+ return merkle_root([data[i:i + 32] for i in range(0, len(data), 32)])
+
return hash(
- merkle_root(
- pad_to_power_of_2([
- merkle_root_of_bytes(zpad(serialize(h), SHARD_BLOCK_SIZE)) for h in headers
- ])
- ) +
- merkle_root(
- pad_to_power_of_2([
- merkle_root_of_bytes(h) for h in bodies
- ])
- )
+ merkle_root(pad_to_power_of_2([
+ merkle_root_of_bytes(zpad(serialize(get_shard_header(block)), BYTES_PER_SHARD_BLOCK_BODY)) for block in blocks
+ ])) +
+ merkle_root(pad_to_power_of_2([
+ merkle_root_of_bytes(block.body) for block in blocks
+ ]))
)
```
-The `shard_chain_commitment` is only valid if it equals `compute_commitment(headers, bodies)`.
+## Object validity
+### Shard blocks
-### Shard block fork choice rule
+Let:
-The fork choice rule for any shard is LMD GHOST using the shard chain attestations of the persistent committee and the beacon chain attestations of the crosslink committee currently assigned to that shard, but instead of being rooted in the genesis it is rooted in the block referenced in the most recent accepted crosslink (ie. `state.crosslinks[shard].shard_block_root`). Only blocks whose `beacon_chain_ref` is the block in the main beacon chain at the specified `slot` should be considered (if the beacon chain skips a slot, then the block at that slot is considered to be the block in the beacon chain at the highest slot lower than a slot).
-
-# Updates to the beacon chain
-
-## Data structures
-
-### `Validator`
-
-Add member values to the end of the `Validator` object:
+* `beacon_blocks` be the `BeaconBlock` list such that `beacon_blocks[slot]` is the canonical `BeaconBlock` at slot `slot`
+* `beacon_state` be the canonical `BeaconState` after processing `beacon_blocks[-1]`
+* `valid_shard_blocks` be the list of valid `ShardBlock`, recursively defined
+* `unix_time` be the current unix time
+* `candidate` be a candidate `ShardBlock` for which validity is to be determined by running `is_valid_shard_block`
```python
- 'next_subkey_to_reveal': 'uint64',
- 'reveal_max_periods_late': 'uint64',
-```
+def is_valid_shard_block(beacon_blocks: List[BeaconBlock],
+ beacon_state: BeaconState,
+ valid_shard_blocks: List[ShardBlock],
+ unix_time: uint64,
+ candidate: ShardBlock) -> bool
+ # Check if block is already determined valid
+ for _, block in enumerate(valid_shard_blocks):
+ if candidate == block:
+ return True
-And the initializers:
+ # Check slot number
+ assert block.slot >= PHASE_1_GENESIS_SLOT
+ assert unix_time >= beacon_state.genesis_time + (block.slot - GENESIS_SLOT) * SECONDS_PER_SLOT
-```python
- 'next_subkey_to_reveal': get_current_custody_period(state),
- 'reveal_max_periods_late': 0,
-```
+ # Check shard number
+ assert block.shard <= SHARD_COUNT
-### `BeaconBlockBody`
+ # Check beacon block
+ beacon_block = beacon_blocks[block.slot]
+ assert block.beacon_block_root == signed_root(beacon_block)
+ assert beacon_block.slot <= block.slot:
-Add member values to the `BeaconBlockBody` structure:
+ # Check state root
+ assert block.state_root == ZERO_HASH # [to be removed in phase 2]
-```python
- 'branch_challenges': [BranchChallenge],
- 'branch_responses': [BranchResponse],
- 'subkey_reveals': [SubkeyReveal],
- 'interactive_custody_challenge_initiations': [InteractiveCustodyChallengeInitiation],
- 'interactive_custody_challenge_responses': [InteractiveCustodyChallengeResponse],
- 'interactive_custody_challenge_continuations': [InteractiveCustodyChallengeContinuation],
-
-```
-
-And initialize to the following:
-
-```python
- 'branch_challenges': [],
- 'branch_responses': [],
- 'subkey_reveals': [],
-```
-
-### `BeaconState`
-
-Add member values to the `BeaconState` structure:
-
-```python
- 'branch_challenge_records': [BranchChallengeRecord],
- 'next_branch_challenge_id': 'uint64',
- 'custody_challenge_records': [InteractiveCustodyChallengeRecord],
- 'next_custody_challenge_id': 'uint64',
-```
-
-### `BranchChallenge`
-
-Define a `BranchChallenge` as follows:
-
-```python
-{
- 'responder_index': 'uint64',
- 'data_index': 'uint64',
- 'attestation': SlashableAttestation,
-}
-```
-
-### `BranchResponse`
-
-Define a `BranchResponse` as follows:
-
-```python
-{
- 'challenge_id': 'uint64',
- 'responding_to_custody_challenge': 'bool',
- 'data': 'bytes32',
- 'branch': ['bytes32'],
-}
-```
-
-### `BranchChallengeRecord`
-
-Define a `BranchChallengeRecord` as follows:
-
-```python
-{
- 'challenge_id': 'uint64',
- 'challenger_index': 'uint64',
- 'responder_index': 'uint64',
- 'root': 'bytes32',
- 'depth': 'uint64',
- 'deadline': 'uint64',
- 'data_index': 'uint64',
-}
-```
-
-### `InteractiveCustodyChallengeRecord`
-
-```python
-{
- 'challenge_id': 'uint64',
- 'challenger_index': 'uint64',
- 'responder_index': 'uint64',
- # Initial data root
- 'data_root': 'bytes32',
- # Initial custody bit
- 'custody_bit': 'bool',
- # Responder subkey
- 'responder_subkey': 'bytes96',
- # The hash in the PoC tree in the position that we are currently at
- 'current_custody_tree_node': 'bytes32',
- # The position in the tree, in terms of depth and position offset
- 'depth': 'uint64',
- 'offset': 'uint64',
- # Max depth of the branch
- 'max_depth': 'uint64',
- # Deadline to respond (as an epoch)
- 'deadline': 'uint64',
-}
-```
-
-### `InteractiveCustodyChallengeInitiation`
-
-```python
-{
- 'attestation': SlashableAttestation,
- 'responder_index': 'uint64',
- 'challenger_index': 'uint64',
- 'responder_subkey': 'bytes96',
- 'signature': 'bytes96',
-}
-```
-
-### `InteractiveCustodyChallengeResponse`
-
-```python
-{
- 'challenge_id': 'uint64',
- 'hashes': ['bytes32'],
- 'signature': 'bytes96',
-}
-```
-
-### `InteractiveCustodyChallengeContinuation`
-
-```python
-{
- 'challenge_id': 'uint64',
- 'sub_index': 'uint64',
- 'new_custody_tree_node': 'bytes32',
- 'proof': ['bytes32'],
- 'signature': 'bytes96',
-}
-```
-
-### `SubkeyReveal`
-
-Define a `SubkeyReveal` as follows:
-
-```python
-{
- 'validator_index': 'uint64',
- 'period': 'uint64',
- 'subkey': 'bytes96',
- 'mask': 'bytes32',
- 'revealer_index': 'uint64'
-}
-```
-
-## Helpers
-
-### `get_branch_challenge_record_by_id`
-
-```python
-def get_branch_challenge_record_by_id(state: BeaconState, id: int) -> BranchChallengeRecord:
- return [c for c in state.branch_challenges if c.challenge_id == id][0]
-```
-
-### `get_custody_challenge_record_by_id`
-
-```python
-def get_custody_challenge_record_by_id(state: BeaconState, id: int) -> BranchChallengeRecord:
- return [c for c in state.branch_challenges if c.challenge_id == id][0]
-```
-
-### `get_attestation_merkle_depth`
-
-```python
-def get_attestation_merkle_depth(attestation: Attestation) -> int:
- start_epoch = attestation.data.latest_crosslink.epoch
- end_epoch = slot_to_epoch(attestation.data.slot)
- chunks_per_slot = SHARD_BLOCK_SIZE // 32
- chunks = (end_epoch - start_epoch) * EPOCH_LENGTH * chunks_per_slot
- return log2(next_power_of_two(chunks))
-```
-
-### `epoch_to_custody_period`
-
-```python
-def epoch_to_custody_period(epoch: Epoch) -> int:
- return epoch // CUSTODY_PERIOD_LENGTH
-```
-
-### `slot_to_custody_period`
-
-```python
-def slot_to_custody_period(slot: Slot) -> int:
- return epoch_to_custody_period(slot_to_epoch(slot))
-```
-
-### `get_current_custody_period`
-
-```python
-def get_current_custody_period(state: BeaconState) -> int:
- return epoch_to_custody_period(get_current_epoch(state))
-```
-
-### `verify_custody_subkey_reveal`
-
-```python
-def verify_custody_subkey_reveal(pubkey: bytes48,
- subkey: bytes96,
- mask: bytes32,
- mask_pubkey: bytes48,
- period: int) -> bool:
- # Legitimate reveal: checking that the provided value actually is the subkey
- if mask == ZERO_HASH:
- pubkeys=[pubkey]
- message_hashes=[hash(int_to_bytes8(period))]
-
- # Punitive early reveal: checking that the provided value is a valid masked subkey
- # (masking done to prevent "stealing the reward" from a whistleblower by block proposers)
- # Secure under the aggregate extraction infeasibility assumption described on page 11-12
- # of https://crypto.stanford.edu/~dabo/pubs/papers/aggreg.pdf
+ # Check parent block
+ if block.slot == PHASE_1_GENESIS_SLOT:
+ assert candidate.previous_block_root == ZERO_HASH
else:
- pubkeys=[pubkey, mask_pubkey]
- message_hashes=[hash(int_to_bytes8(period)), mask]
-
- return bls_multi_verify(
- pubkeys=pubkeys,
- message_hashes=message_hashes,
- signature=subkey,
- domain=get_domain(
- fork=state.fork,
- epoch=period * CUSTODY_PERIOD_LENGTH,
- domain_type=DOMAIN_CUSTODY_SUBKEY,
- )
- )
-```
+ parent_block = next(
+ block for block in valid_shard_blocks if
+ signed_root(block) == candidate.previous_block_root
+ , None)
+ assert parent_block != None
+ assert parent_block.shard == block.shard
+ assert parent_block.slot < block.slot
+ assert signed_root(beacon_blocks[parent_block.slot]) == parent_block.beacon_chain_root
-### `verify_signed_challenge_message`
+ # Check attestations
+ assert len(block.attestations) <= MAX_SHARD_ATTESTIONS
+ for _, attestation in enumerate(block.attestations):
+ assert max(GENESIS_SHARD_SLOT, block.slot - SLOTS_PER_EPOCH) <= attestation.data.slot
+ assert attesation.data.slot <= block.slot - MIN_ATTESTATION_INCLUSION_DELAY
+ assert attetation.data.shart == block.shard
+ verify_shard_attestation_signature(beacon_state, attestation)
-```python
-def verify_signed_challenge_message(message: Any, pubkey: bytes48) -> bool:
- return bls_verify(
- message_hash=signed_root(message),
- pubkey=pubkey,
- signature=message.signature,
- domain=get_domain(state, get_current_epoch(state), DOMAIN_CUSTODY_INTERACTIVE)
+ # Check signature
+ proposer_index = get_shard_proposer_index(beacon_state, block.shard, block.slot)
+ assert proposer_index is not None
+ assert bls_verify(
+ pubkey=validators[proposer_index].pubkey,
+ message_hash=signed_root(block),
+ signature=block.signature,
+ domain=get_domain(beacon_state, slot_to_epoch(block.slot), DOMAIN_SHARD_PROPOSER)
)
+ return True
```
-### `penalize_validator`
+### Shard attestations
-Change the definition of `penalize_validator` as follows:
+Let:
+
+* `valid_shard_blocks` be the list of valid `ShardBlock`
+* `beacon_state` be the canonical `BeaconState`
+* `candidate` be a candidate `ShardAttestation` for which validity is to be determined by running `is_valid_shard_attestation`
```python
-def penalize_validator(state: BeaconState, index: ValidatorIndex, whistleblower_index=None:ValidatorIndex) -> None:
- """
- Penalize the validator of the given ``index``.
- Note that this function mutates ``state``.
- """
- exit_validator(state, index)
- validator = state.validator_registry[index]
- state.latest_penalized_balances[get_current_epoch(state) % LATEST_PENALIZED_EXIT_LENGTH] += get_effective_balance(state, index)
-
- block_proposer_index = get_beacon_proposer_index(state, state.slot)
- whistleblower_reward = get_effective_balance(state, index) // WHISTLEBLOWER_REWARD_QUOTIENT
- if whistleblower_index is None:
- state.validator_balances[block_proposer_index] += whistleblower_reward
+def is_valid_shard_attestation(valid_shard_blocks: List[ShardBlock],
+ beacon_state: BeaconState,
+ candidate: Attestation) -> bool:
+ # Check shard block
+ shard_block = next(
+ block for block in valid_shard_blocks if
+ signed_root(block) == candidate.attestation.data.shard_block_root
+ , None)
+ assert shard_block != None
+ assert shard_block.slot == attestation.data.slot
+ assert shard_block.shard == attestation.data.shard
+
+ # Check signature
+ verify_shard_attestation_signature(beacon_state, attestation)
+
+ return True
+```
+
+### Beacon attestations
+
+Let:
+
+* `shard` be a valid `Shard`
+* `shard_blocks` be the `ShardBlock` list such that `shard_blocks[slot]` is the canonical `ShardBlock` for shard `shard` at slot `slot`
+* `beacon_state` be the canonical `BeaconState`
+* `valid_attestations` be the list of valid `Attestation`, recursively defined
+* `candidate` be a candidate `Attestation` which is valid under phase 0 rules, and for which validity is to be determined under phase 1 rules by running `is_valid_beacon_attestation`
+
+```python
+def is_valid_beacon_attestation(shard: Shard,
+ shard_blocks: List[ShardBlock],
+ beacon_state: BeaconState,
+ valid_attestations: List[Attestation],
+ candidate: Attestation) -> bool:
+ # Check if attestation is already determined valid
+ for _, attestation in enumerate(valid_attestations):
+ if candidate == attestation:
+ return True
+
+ # Check previous attestation
+ if candidate.data.previous_crosslink.epoch <= PHASE_1_GENESIS_EPOCH:
+ assert candidate.data.previous_crosslink.crosslink_data_root == ZERO_HASH
else:
- state.validator_balances[whistleblower_index] += (
- whistleblower_reward * INCLUDER_REWARD_QUOTIENT / (INCLUDER_REWARD_QUOTIENT + 1)
- )
- state.validator_balances[block_proposer_index] += whistleblower_reward / (INCLUDER_REWARD_QUOTIENT + 1)
- state.validator_balances[index] -= whistleblower_reward
- validator.penalized_epoch = get_current_epoch(state)
- validator.withdrawable_epoch = get_current_epoch(state) + LATEST_PENALIZED_EXIT_LENGTH
+ previous_attestation = next(
+ attestation for attestation in valid_attestations if
+ attestation.data.crosslink_data_root == candidate.data.previous_crosslink.crosslink_data_root
+ , None)
+ assert previous_attestation != None
+ assert candidate.data.previous_attestation.epoch < slot_to_epoch(candidate.data.slot)
+
+ # Check crosslink data root
+ start_epoch = state.latest_crosslinks[shard].epoch
+ end_epoch = min(slot_to_epoch(candidate.data.slot) - CROSSLINK_LOOKBACK, start_epoch + MAX_CROSSLINK_EPOCHS)
+ blocks = []
+ for slot in range(start_epoch * SLOTS_PER_EPOCH, end_epoch * SLOTS_PER_EPOCH):
+ blocks.append(shard_blocks[slot])
+ assert candidate.data.crosslink_data_root == compute_crosslink_data_root(blocks)
+
+ return True
```
-The only change is that this introduces the possibility of a penalization where the "whistleblower" that takes credit is NOT the block proposer.
+## Shard fork choice rule
-## Per-slot processing
-
-### Operations
-
-Add the following operations to the per-slot processing, in order the given below and _after_ all other operations (specifically, right after exits).
-
-#### Branch challenges
-
-Verify that `len(block.body.branch_challenges) <= MAX_BRANCH_CHALLENGES`.
-
-For each `challenge` in `block.body.branch_challenges`, run:
-
-```python
-def process_branch_challenge(state: BeaconState,
- challenge: BranchChallenge) -> None:
- # Check that it's not too late to challenge
- assert slot_to_epoch(challenge.attestation.data.slot) >= get_current_epoch(state) - MAX_BRANCH_CHALLENGE_DELAY
- assert state.validator_registry[responder_index].exit_epoch >= get_current_epoch(state) - MAX_BRANCH_CHALLENGE_DELAY
- # Check the attestation is valid
- assert verify_slashable_attestation(state, challenge.attestation)
- # Check that the responder participated
- assert challenger.responder_index in challenge.attestation.validator_indices
- # Check the challenge is not a duplicate
- assert [
- c for c in state.branch_challenge_records if c.root == challenge.attestation.data.crosslink_data_root and
- c.data_index == challenge.data_index
- ] == []
- # Check validity of depth
- depth = get_attestation_merkle_depth(challenge.attestation)
- assert c.data_index < 2**depth
- # Add new challenge
- state.branch_challenge_records.append(BranchChallengeRecord(
- challenge_id=state.next_branch_challenge_id,
- challenger_index=get_beacon_proposer_index(state, state.slot),
- root=challenge.attestation.data.shard_chain_commitment,
- depth=depth,
- deadline=get_current_epoch(state) + CHALLENGE_RESPONSE_DEADLINE,
- data_index=challenge.data_index
- ))
- state.next_branch_challenge_id += 1
-```
-
-#### Branch responses
-
-Verify that `len(block.body.branch_responses) <= MAX_BRANCH_RESPONSES`.
-
-For each `response` in `block.body.branch_responses`, if `response.responding_to_custody_challenge == False`, run:
-
-```python
-def process_branch_exploration_response(state: BeaconState,
- response: BranchResponse) -> None:
- challenge = get_branch_challenge_record_by_id(response.challenge_id)
- assert verify_merkle_branch(
- leaf=response.data,
- branch=response.branch,
- depth=challenge.depth,
- index=challenge.data_index,
- root=challenge.root
- )
- # Must wait at least ENTRY_EXIT_DELAY before responding to a branch challenge
- assert get_current_epoch(state) >= challenge.inclusion_epoch + ENTRY_EXIT_DELAY
- state.branch_challenge_records.pop(challenge)
- # Reward the proposer
- proposer_index = get_beacon_proposer_index(state, state.slot)
- state.validator_balances[proposer_index] += base_reward(state, index) // MINOR_REWARD_QUOTIENT
-```
-
-If `response.responding_to_custody_challenge == True`, run:
-
-```python
-def process_branch_custody_response(state: BeaconState,
- response: BranchResponse) -> None:
- challenge = get_custody_challenge_record_by_id(response.challenge_id)
- responder = state.validator_registry[challenge.responder_index]
- # Verify we're not too late
- assert get_current_epoch(state) < responder.withdrawable_epoch
- # Verify the Merkle branch *of the data tree*
- assert verify_merkle_branch(
- leaf=response.data,
- branch=response.branch,
- depth=challenge.max_depth,
- index=challenge.offset,
- root=challenge.data_root
- )
- # Responder wins
- if hash(challenge.responder_subkey + response.data) == challenge.current_custody_tree_node:
- penalize_validator(state, challenge.challenger_index, challenge.responder_index)
- # Challenger wins
- else:
- penalize_validator(state, challenge.responder_index, challenge.challenger_index)
- state.custody_challenge_records.pop(challenge)
-```
-
-#### Subkey reveals
-
-Verify that `len(block.body.early_subkey_reveals) <= MAX_EARLY_SUBKEY_REVEALS`.
-
-For each `reveal` in `block.body.early_subkey_reveals`:
-
-* Verify that `verify_custody_subkey_reveal(state.validator_registry[reveal.validator_index].pubkey, reveal.subkey, reveal.period, reveal.mask, state.validator_registry[reveal.revealer_index].pubkey)` returns `True`.
-* Let `is_early_reveal = reveal.period > get_current_custody_period(state) or (reveal.period == get_current_custody_period(state) and state.validator_registry[reveal.validator_index].exit_epoch > get_current_epoch(state))` (ie. either the reveal is of a future period, or it's of the current period and the validator is still active)
-* Verify that one of the following is true:
- * (i) `is_early_reveal` is `True`
- * (ii) `is_early_reveal` is `False` and `reveal.period == state.validator_registry[reveal.validator_index].next_subkey_to_reveal` (revealing a past subkey, or a current subkey for a validator that has exited) and `reveal.mask == ZERO_HASH`
-
-In case (i):
-
-* Verify that `state.validator_registry[reveal.validator_index].penalized_epoch > get_current_epoch(state).
-* Run `penalize_validator(state, reveal.validator_index, reveal.revealer_index)`.
-* Set `state.validator_balances[reveal.revealer_index] += base_reward(state, index) // MINOR_REWARD_QUOTIENT`
-
-In case (ii):
-
-* Determine the proposer `proposer_index = get_beacon_proposer_index(state, state.slot)` and set `state.validator_balances[proposer_index] += base_reward(state, index) // MINOR_REWARD_QUOTIENT`.
-* Set `state.validator_registry[reveal.validator_index].next_subkey_to_reveal += 1`
-* Set `state.validator_registry[reveal.validator_index].reveal_max_periods_late = max(state.validator_registry[reveal.validator_index].reveal_max_periods_late, get_current_period(state) - reveal.period)`.
-
-#### Interactive custody challenge initiations
-
-Verify that `len(block.body.interactive_custody_challenge_initiations) <= MAX_INTERACTIVE_CUSTODY_CHALLENGE_INITIATIONS`.
-
-For each `initiation` in `block.body.interactive_custody_challenge_initiations`, use the following function to process it:
-
-```python
-def process_initiation(state: BeaconState,
- initiation: InteractiveCustodyChallengeInitiation) -> None:
- challenger = state.validator_registry[initiation.challenger_index]
- responder = state.validator_registry[initiation.responder_index]
- # Verify the signature
- assert verify_signed_challenge_message(initiation, challenger.pubkey)
- # Verify the attestation
- assert verify_slashable_attestation(initiation.attestation, state)
- # Check that the responder actually participated in the attestation
- assert initiation.responder_index in attestation.validator_indices
- # Any validator can be a challenger or responder of max 1 challenge at a time
- for c in state.custody_challenge_records:
- assert c.challenger_index != initiation.challenger_index
- assert c.responder_index != initiation.responder_index
- # Can't challenge if you've been penalized
- assert challenger.penalized_epoch == FAR_FUTURE_EPOCH
- # Make sure the revealed subkey is valid
- assert verify_custody_subkey_reveal(
- pubkey=state.validator_registry[responder_index].pubkey,
- subkey=initiation.responder_subkey,
- period=slot_to_custody_period(attestation.data.slot)
- )
- # Verify that the attestation is still eligible for challenging
- min_challengeable_epoch = responder.exit_epoch - CUSTODY_PERIOD_LENGTH * (1 + responder.reveal_max_periods_late)
- assert min_challengeable_epoch <= slot_to_epoch(initiation.attestation.data.slot)
- # Create a new challenge object
- state.branch_challenge_records.append(InteractiveCustodyChallengeRecord(
- challenge_id=state.next_branch_challenge_id,
- challenger_index=initiation.challenger_index,
- responder_index=initiation.responder_index,
- data_root=attestation.custody_commitment,
- custody_bit=get_bitfield_bit(attestation.custody_bitfield, attestation.validator_indices.index(responder_index)),
- responder_subkey=responder_subkey,
- current_custody_tree_node=ZERO_HASH,
- depth=0,
- offset=0,
- max_depth=get_attestation_data_merkle_depth(initiation.attestation.data),
- deadline=get_current_epoch(state) + CHALLENGE_RESPONSE_DEADLINE
- ))
- state.next_branch_challenge_id += 1
- # Responder can't withdraw yet!
- state.validator_registry[responder_index].withdrawable_epoch = FAR_FUTURE_EPOCH
-```
-
-#### Interactive custody challenge responses
-
-A response provides 32 hashes that are under current known proof of custody tree node. Note that at the beginning the tree node is just one bit of the custody root, so we ask the responder to sign to commit to the top 5 levels of the tree and therefore the root hash; at all other stages in the game responses are self-verifying.
-
-Verify that `len(block.body.interactive_custody_challenge_responses) <= MAX_INTERACTIVE_CUSTODY_CHALLENGE_RESPONSES`.
-
-For each `response` in `block.body.interactive_custody_challenge_responses`, use the following function to process it:
-
-```python
-def process_response(state: BeaconState,
- response: InteractiveCustodyChallengeResponse) -> None:
- challenge = get_custody_challenge_record_by_id(state, response.challenge_id)
- responder = state.validator_registry[challenge.responder_index]
- # Check that the right number of hashes was provided
- expected_depth = min(challenge.max_depth - challenge.depth, MAX_POC_RESPONSE_DEPTH)
- assert 2**expected_depth == len(response.hashes)
- # Must make some progress!
- assert expected_depth > 0
- # Check the hashes match the previously provided root
- root = merkle_root(response.hashes)
- # If this is the first response check the bit and the signature and set the root
- if challenge.depth == 0:
- assert get_bitfield_bit(root, 0) == challenge.custody_bit
- assert verify_signed_challenge_message(response, responder.pubkey)
- challenge.current_custody_tree_node = root
- # Otherwise just check the response against the root
- else:
- assert root == challenge_data.current_custody_tree_node
- # Update challenge data
- challenge.deadline=FAR_FUTURE_EPOCH
- responder.withdrawable_epoch = get_current_epoch(state) + MAX_POC_RESPONSE_DEPTH
-```
-
-#### Interactive custody challenge continuations
-
-Once a response provides 32 hashes, the challenger has the right to choose any one of them that they feel is constructed incorrectly to continue the game. Note that eventually, the game will get to the point where the `new_custody_tree_node` is a leaf node.
-
-Verify that `len(block.body.interactive_custody_challenge_continuations) <= MAX_INTERACTIVE_CUSTODY_CHALLENGE_CONTINUATIONS`.
-
-For each `continuation` in `block.body.interactive_custody_challenge_continuations`, use the following function to process it:
-
-```python
-def process_continuation(state: BeaconState,
- continuation: InteractiveCustodyChallengeContinuation) -> None:
- challenge = get_custody_challenge_record_by_id(state, continuation.challenge_id)
- challenger = state.validator_registry[challenge.challenger_index]
- responder = state.validator_registry[challenge.responder_index]
- expected_depth = min(challenge_data.max_depth - challenge_data.depth, MAX_POC_RESPONSE_DEPTH)
- # Verify we're not too late
- assert get_current_epoch(state) < responder.withdrawable_epoch
- # Verify the Merkle branch (the previous custody response provided the next level of hashes so the
- # challenger has the info to make any Merkle branch)
- assert verify_merkle_branch(
- leaf=new_custody_tree_node,
- branch=continuation.proof,
- depth=expected_depth,
- index=sub_index,
- root=challenge_data.current_custody_tree_node
- )
- # Verify signature
- assert verify_signed_challenge_message(continuation, challenger.pubkey)
- # Update the challenge data
- challenge.current_custody_tree_node = continuation.new_custody_tree_node
- challenge.depth += expected_depth
- challenge.deadline = get_current_epoch(state) + MAX_POC_RESPONSE_DEPTH
- responder.withdrawable_epoch = FAR_FUTURE_EPOCH
- challenge.offset = challenge_data.offset * 2**expected_depth + sub_index
-```
-
-## Per-epoch processing
-
-Add the following loop immediately below the `process_ejections` loop:
-
-```python
-def process_challenge_absences(state: BeaconState) -> None:
- """
- Iterate through the challenge list
- and penalize validators with balance that did not answer challenges.
- """
- for c in state.branch_challenge_records:
- if get_current_epoch(state) > c.deadline:
- penalize_validator(state, c.responder_index, c.challenger_index)
-
- for c in state.custody_challenge_records:
- if get_current_epoch(state) > c.deadline:
- penalize_validator(state, c.responder_index, c.challenger_index)
- if get_current_epoch(state) > state.validator_registry[c.responder_index].withdrawable_epoch:
- penalize_validator(state, c.challenger_index, c.responder_index)
-```
-
-In `process_penalties_and_exits`, change the definition of `eligible` to the following (note that it is not a pure function because `state` is declared in the surrounding scope):
-
-```python
-def eligible(index):
- validator = state.validator_registry[index]
- # Cannot exit if there are still open branch challenges
- if [c for c in state.branch_challenge_records if c.responder_index == index] != []:
- return False
- # Cannot exit if you have not revealed all of your subkeys
- elif validator.next_subkey_to_reveal <= epoch_to_custody_period(validator.exit_epoch):
- return False
- # Cannot exit if you already have
- elif validator.withdrawable_epoch < FAR_FUTURE_EPOCH:
- return False
- # Return minimum time
- else:
- return current_epoch >= validator.exit_epoch + MIN_VALIDATOR_WITHDRAWAL_EPOCHS
-```
-
-## One-time phase 1 initiation transition
-
-Run the following on the fork block after per-slot processing and before per-block and per-epoch processing.
-
-For all `validator` in `ValidatorRegistry`, update it to the new format and fill the new member values with:
-
-```python
- 'next_subkey_to_reveal': get_current_custody_period(state),
- 'reveal_max_periods_late': 0,
-```
-
-Update the `BeaconState` to the new format and fill the new member values with:
-
-```python
- 'branch_challenge_records': [],
- 'next_branch_challenge_id': 0,
- 'custody_challenge_records': [],
- 'next_custody_challenge_id': 0,
-```
+The fork choice rule for any shard is LMD GHOST using the shard attestations of the persistent committee and the beacon chain attestations of the crosslink committee currently assigned to that shard, but instead of being rooted in the genesis it is rooted in the block referenced in the most recent accepted crosslink (i.e. `state.crosslinks[shard].shard_block_root`). Only blocks whose `beacon_chain_root` is the block in the main beacon chain at the specified `slot` should be considered. (If the beacon chain skips a slot, then the block at that slot is considered to be the block in the beacon chain at the highest slot lower than a slot.)
diff --git a/test_libs/pyspec/pyspec/phase0/state_transition.py b/test_libs/pyspec/pyspec/phase0/state_transition.py
index f2fb68f6b..59ff07d37 100644
--- a/test_libs/pyspec/pyspec/phase0/state_transition.py
+++ b/test_libs/pyspec/pyspec/phase0/state_transition.py
@@ -20,31 +20,31 @@ def expected_deposit_count(state: BeaconState) -> int:
)
-def process_transaction_type(state: BeaconState,
- transactions: List[Any],
- max_transactions: int,
- tx_fn: Callable[[BeaconState, Any], None]) -> None:
- assert len(transactions) <= max_transactions
- for transaction in transactions:
- tx_fn(state, transaction)
+def process_operation_type(state: BeaconState,
+ operations: List[Any],
+ max_operations: int,
+ tx_fn: Callable[[BeaconState, Any], None]) -> None:
+ assert len(operations) <= max_operations
+ for operation in operations:
+ tx_fn(state, operation)
-def process_transactions(state: BeaconState, block: BeaconBlock) -> None:
- process_transaction_type(
+def process_operations(state: BeaconState, block: BeaconBlock) -> None:
+ process_operation_type(
state,
block.body.proposer_slashings,
spec.MAX_PROPOSER_SLASHINGS,
spec.process_proposer_slashing,
)
- process_transaction_type(
+ process_operation_type(
state,
block.body.attester_slashings,
spec.MAX_ATTESTER_SLASHINGS,
spec.process_attester_slashing,
)
- process_transaction_type(
+ process_operation_type(
state,
block.body.attestations,
spec.MAX_ATTESTATIONS,
@@ -52,14 +52,14 @@ def process_transactions(state: BeaconState, block: BeaconBlock) -> None:
)
assert len(block.body.deposits) == expected_deposit_count(state)
- process_transaction_type(
+ process_operation_type(
state,
block.body.deposits,
spec.MAX_DEPOSITS,
spec.process_deposit,
)
- process_transaction_type(
+ process_operation_type(
state,
block.body.voluntary_exits,
spec.MAX_VOLUNTARY_EXITS,
@@ -67,7 +67,7 @@ def process_transactions(state: BeaconState, block: BeaconBlock) -> None:
)
assert len(block.body.transfers) == len(set(block.body.transfers))
- process_transaction_type(
+ process_operation_type(
state,
block.body.transfers,
spec.MAX_TRANSFERS,
@@ -82,7 +82,7 @@ def process_block(state: BeaconState,
spec.process_randao(state, block)
spec.process_eth1_data(state, block)
- process_transactions(state, block)
+ process_operations(state, block)
if verify_state_root:
spec.verify_block_state_root(state, block)