diff --git a/.circleci/config.yml b/.circleci/config.yml
new file mode 100644
index 000000000..02871530e
--- /dev/null
+++ b/.circleci/config.yml
@@ -0,0 +1,41 @@
+# Python CircleCI 2.0 configuration file
+version: 2
+jobs:
+ build:
+ docker:
+ - image: circleci/python:3.6
+ working_directory: ~/repo
+
+ steps:
+ - checkout
+ # Download and cache dependencies
+ - restore_cache:
+ keys:
+ - v1-dependencies-{{ checksum "requirements.txt" }}
+ # fallback to using the latest cache if no exact match is found
+ - v1-dependencies-
+
+ - run:
+ name: install dependencies
+ command: |
+ python3 -m venv venv
+ . venv/bin/activate
+ pip install -r requirements.txt
+ - run:
+ name: build phase0 spec
+ command: make build/phase0
+
+ - save_cache:
+ paths:
+ - ./venv
+ key: v1-dependencies-{{ checksum "requirements.txt" }}
+
+ - run:
+ name: run tests
+ command: |
+ . venv/bin/activate
+ pytest tests
+
+ - store_artifacts:
+ path: test-reports
+ destination: test-reports
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 000000000..f33dd5256
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+*.pyc
+/__pycache__
+/venv
+/.pytest_cache
+
+build/
+output/
diff --git a/Makefile b/Makefile
new file mode 100644
index 000000000..88f17dcf9
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,29 @@
+SPEC_DIR = ./specs
+SCRIPT_DIR = ./scripts
+BUILD_DIR = ./build
+UTILS_DIR = ./utils
+
+
+.PHONY: clean all test
+
+
+all: $(BUILD_DIR)/phase0
+
+
+clean:
+ rm -rf $(BUILD_DIR)
+
+
+# runs a limited set of tests against a minimal config
+# run pytest with `-m` option to full suite
+test:
+ pytest -m minimal_config tests/
+
+
+$(BUILD_DIR)/phase0:
+ mkdir -p $@
+ python3 $(SCRIPT_DIR)/phase0/build_spec.py $(SPEC_DIR)/core/0_beacon-chain.md $@/spec.py
+ mkdir -p $@/utils
+ cp $(UTILS_DIR)/phase0/* $@/utils
+ cp $(UTILS_DIR)/phase0/state_transition.py $@
+ touch $@/__init__.py $@/utils/__init__.py
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 000000000..9145e951e
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,6 @@
+eth-utils>=1.3.0,<2
+eth-typing>=2.1.0,<3.0.0
+oyaml==0.7
+pycryptodome==3.7.3
+py_ecc>=1.6.0
+pytest>=3.6,<3.7
diff --git a/scripts/__init__.py b/scripts/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/scripts/phase0/__init__.py b/scripts/phase0/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/scripts/phase0/build_spec.py b/scripts/phase0/build_spec.py
new file mode 100644
index 000000000..6116f1ffe
--- /dev/null
+++ b/scripts/phase0/build_spec.py
@@ -0,0 +1,79 @@
+import sys
+import function_puller
+
+
+def build_spec(sourcefile, outfile):
+ code_lines = []
+
+ code_lines.append("from build.phase0.utils.minimal_ssz import *")
+ code_lines.append("from build.phase0.utils.bls_stub import *")
+ for i in (1, 2, 3, 4, 8, 32, 48, 96):
+ code_lines.append("def int_to_bytes%d(x): return x.to_bytes(%d, 'little')" % (i, i))
+ code_lines.append("SLOTS_PER_EPOCH = 64") # stub, will get overwritten by real var
+ code_lines.append("def slot_to_epoch(x): return x // SLOTS_PER_EPOCH")
+
+ code_lines.append("""
+from typing import (
+ Any,
+ Callable,
+ List,
+ NewType,
+ Tuple,
+)
+
+
+Slot = NewType('Slot', int) # uint64
+Epoch = NewType('Epoch', int) # uint64
+Shard = NewType('Shard', int) # uint64
+ValidatorIndex = NewType('ValidatorIndex', int) # uint64
+Gwei = NewType('Gwei', int) # uint64
+Bytes32 = NewType('Bytes32', bytes) # bytes32
+BLSPubkey = NewType('BLSPubkey', bytes) # bytes48
+BLSSignature = NewType('BLSSignature', bytes) # bytes96
+Any = None
+Store = None
+ """)
+
+ code_lines += function_puller.get_lines(sourcefile)
+
+ code_lines.append("""
+# Monkey patch validator get committee code
+_compute_committee = compute_committee
+committee_cache = {}
+def compute_committee(validator_indices: List[ValidatorIndex],
+ seed: Bytes32,
+ index: int,
+ total_committees: int) -> List[ValidatorIndex]:
+
+ param_hash = (hash_tree_root(validator_indices), seed, index, total_committees)
+
+ if param_hash in committee_cache:
+ # print("Cache hit, epoch={0}".format(epoch))
+ return committee_cache[param_hash]
+ else:
+ # print("Cache miss, epoch={0}".format(epoch))
+ ret = _compute_committee(validator_indices, seed, index, total_committees)
+ committee_cache[param_hash] = ret
+ return ret
+
+
+# Monkey patch hash cache
+_hash = hash
+hash_cache = {}
+def hash(x):
+ if x in hash_cache:
+ return hash_cache[x]
+ else:
+ ret = _hash(x)
+ hash_cache[x] = ret
+ return ret
+ """)
+
+ with open(outfile, 'w') as out:
+ out.write("\n".join(code_lines))
+
+
+if __name__ == '__main__':
+ if len(sys.argv) < 3:
+ print("Error: spec source and outfile must defined")
+ build_spec(sys.argv[1], sys.argv[2])
diff --git a/scripts/phase0/function_puller.py b/scripts/phase0/function_puller.py
new file mode 100644
index 000000000..7d5796fc7
--- /dev/null
+++ b/scripts/phase0/function_puller.py
@@ -0,0 +1,46 @@
+import sys
+
+
+def get_lines(file_name):
+ code_lines = []
+ pulling_from = None
+ current_name = None
+ processing_typedef = False
+ for linenum, line in enumerate(open(sys.argv[1]).readlines()):
+ line = line.rstrip()
+ if pulling_from is None and len(line) > 0 and line[0] == '#' and line[-1] == '`':
+ current_name = line[line[:-1].rfind('`') + 1: -1]
+ if line[:9] == '```python':
+ assert pulling_from is None
+ pulling_from = linenum + 1
+ elif line[:3] == '```':
+ if pulling_from is None:
+ pulling_from = linenum
+ else:
+ if processing_typedef:
+ assert code_lines[-1] == '}'
+ code_lines[-1] = '})'
+ pulling_from = None
+ processing_typedef = False
+ else:
+ if pulling_from == linenum and line == '{':
+ code_lines.append('%s = SSZType({' % current_name)
+ processing_typedef = True
+ elif pulling_from is not None:
+ code_lines.append(line)
+ elif pulling_from is None and len(line) > 0 and line[0] == '|':
+ row = line[1:].split('|')
+ if len(row) >= 2:
+ for i in range(2):
+ row[i] = row[i].strip().strip('`')
+ if '`' in row[i]:
+ row[i] = row[i][:row[i].find('`')]
+ eligible = True
+ if row[0][0] not in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_':
+ eligible = False
+ for c in row[0]:
+ if c not in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789':
+ eligible = False
+ if eligible:
+ code_lines.append(row[0] + ' = ' + (row[1].replace('**TBD**', '0x1234567890123567890123456789012357890')))
+ return code_lines
diff --git a/specs/bls_signature.md b/specs/bls_signature.md
index b0490b7ae..14a4f1cb7 100644
--- a/specs/bls_signature.md
+++ b/specs/bls_signature.md
@@ -110,11 +110,11 @@ def modular_squareroot(value: Fq2) -> Fq2:
### `bls_aggregate_pubkeys`
-Let `bls_aggregate_pubkeys(pubkeys: List[Bytes48]) -> Bytes48` return `pubkeys[0] + .... + pubkeys[len(pubkeys)-1]`, where `+` is the elliptic curve addition operation over the G1 curve.
+Let `bls_aggregate_pubkeys(pubkeys: List[Bytes48]) -> Bytes48` return `pubkeys[0] + .... + pubkeys[len(pubkeys)-1]`, where `+` is the elliptic curve addition operation over the G1 curve. (When `len(pubkeys) == 0` the empty sum is the G1 point at infinity.)
### `bls_aggregate_signatures`
-Let `bls_aggregate_signatures(signatures: List[Bytes96]) -> Bytes96` return `signatures[0] + .... + signatures[len(signatures)-1]`, where `+` is the elliptic curve addition operation over the G2 curve.
+Let `bls_aggregate_signatures(signatures: List[Bytes96]) -> Bytes96` return `signatures[0] + .... + signatures[len(signatures)-1]`, where `+` is the elliptic curve addition operation over the G2 curve. (When `len(signatures) == 0` the empty sum is the G2 point at infinity.)
## Signature verification
diff --git a/specs/core/0_beacon-chain.md b/specs/core/0_beacon-chain.md
index bd0187a9f..d08828692 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
@@ -28,8 +28,7 @@
- [`Eth1DataVote`](#eth1datavote)
- [`AttestationData`](#attestationdata)
- [`AttestationDataAndCustodyBit`](#attestationdataandcustodybit)
- - [`SlashableAttestation`](#slashableattestation)
- - [`DepositInput`](#depositinput)
+ - [`IndexedAttestation`](#indexedattestation)
- [`DepositData`](#depositdata)
- [`BeaconBlockHeader`](#beaconblockheader)
- [`Validator`](#validator)
@@ -59,14 +58,17 @@
- [`get_current_epoch`](#get_current_epoch)
- [`get_epoch_start_slot`](#get_epoch_start_slot)
- [`is_active_validator`](#is_active_validator)
+ - [`is_slashable_validator`](#is_slashable_validator)
- [`get_active_validator_indices`](#get_active_validator_indices)
+ - [`get_balance`](#get_balance)
+ - [`set_balance`](#set_balance)
+ - [`increase_balance`](#increase_balance)
+ - [`decrease_balance`](#decrease_balance)
- [`get_permuted_index`](#get_permuted_index)
- - [`split`](#split)
+ - [`get_split_offset`](#get_split_offset)
- [`get_epoch_committee_count`](#get_epoch_committee_count)
- - [`get_shuffling`](#get_shuffling)
- - [`get_previous_epoch_committee_count`](#get_previous_epoch_committee_count)
+ - [`compute_committee`](#compute_committee)
- [`get_current_epoch_committee_count`](#get_current_epoch_committee_count)
- - [`get_next_epoch_committee_count`](#get_next_epoch_committee_count)
- [`get_crosslink_committees_at_slot`](#get_crosslink_committees_at_slot)
- [`get_block_root`](#get_block_root)
- [`get_state_root`](#get_state_root)
@@ -75,8 +77,8 @@
- [`generate_seed`](#generate_seed)
- [`get_beacon_proposer_index`](#get_beacon_proposer_index)
- [`verify_merkle_branch`](#verify_merkle_branch)
+ - [`get_crosslink_committee_for_attestation`](#get_crosslink_committee_for_attestation)
- [`get_attestation_participants`](#get_attestation_participants)
- - [`is_power_of_two`](#is_power_of_two)
- [`int_to_bytes1`, `int_to_bytes2`, ...](#int_to_bytes1-int_to_bytes2-)
- [`bytes_to_int`](#bytes_to_int)
- [`get_effective_balance`](#get_effective_balance)
@@ -85,7 +87,8 @@
- [`get_domain`](#get_domain)
- [`get_bitfield_bit`](#get_bitfield_bit)
- [`verify_bitfield`](#verify_bitfield)
- - [`verify_slashable_attestation`](#verify_slashable_attestation)
+ - [`convert_to_indexed`](#convert_to_indexed)
+ - [`verify_indexed_attestation`](#verify_indexed_attestation)
- [`is_double_vote`](#is_double_vote)
- [`is_surround_vote`](#is_surround_vote)
- [`integer_squareroot`](#integer_squareroot)
@@ -115,7 +118,7 @@
- [Helper functions](#helper-functions-1)
- [Justification](#justification)
- [Crosslinks](#crosslinks)
- - [Eth1 data](#eth1-data-1)
+ - [Eth1 data](#eth1-data)
- [Rewards and penalties](#rewards-and-penalties)
- [Justification and finalization](#justification-and-finalization)
- [Crosslinks](#crosslinks-1)
@@ -128,7 +131,7 @@
- [Per-block processing](#per-block-processing)
- [Block header](#block-header)
- [RANDAO](#randao)
- - [Eth1 data](#eth1-data)
+ - [Eth1 data](#eth1-data-1)
- [Transactions](#transactions)
- [Proposer slashings](#proposer-slashings)
- [Attester slashings](#attester-slashings)
@@ -148,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
@@ -158,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
@@ -182,11 +185,11 @@ Code snippets appearing in `this style` are to be interpreted as Python code.
| `SHARD_COUNT` | `2**10` (= 1,024) |
| `TARGET_COMMITTEE_SIZE` | `2**7` (= 128) |
| `MAX_BALANCE_CHURN_QUOTIENT` | `2**5` (= 32) |
-| `MAX_INDICES_PER_SLASHABLE_VOTE` | `2**12` (= 4,096) |
+| `MAX_ATTESTATION_PARTICIPANTS` | `2**12` (= 4,096) |
| `MAX_EXIT_DEQUEUES_PER_EPOCH` | `2**2` (= 4) |
| `SHUFFLE_ROUND_COUNT` | 90 |
-* For the safety of crosslinks `TARGET_COMMITTEE_SIZE` exceeds [the recommended minimum committee size of 111](https://vitalik.ca/files/Ithaca201807_Sharding.pdf); with sufficient active validators (at least `SLOTS_PER_EPOCH * TARGET_COMMITTEE_SIZE`), the shuffling algorithm ensures committee sizes at least `TARGET_COMMITTEE_SIZE`. (Unbiasable randomness with a Verifiable Delay Function (VDF) will improve committee robustness and lower the safe minimum committee size.)
+* For the safety of crosslinks `TARGET_COMMITTEE_SIZE` exceeds [the recommended minimum committee size of 111](https://vitalik.ca/files/Ithaca201807_Sharding.pdf); with sufficient active validators (at least `SLOTS_PER_EPOCH * TARGET_COMMITTEE_SIZE`), the shuffling algorithm ensures committee sizes of at least `TARGET_COMMITTEE_SIZE`. (Unbiasable randomness with a Verifiable Delay Function (VDF) will improve committee robustness and lower the safe minimum committee size.)
### Deposit contract
@@ -201,14 +204,14 @@ Code snippets appearing in `this style` are to be interpreted as Python code.
| - | - | :-: |
| `MIN_DEPOSIT_AMOUNT` | `2**0 * 10**9` (= 1,000,000,000) | Gwei |
| `MAX_DEPOSIT_AMOUNT` | `2**5 * 10**9` (= 32,000,000,000) | Gwei |
-| `FORK_CHOICE_BALANCE_INCREMENT` | `2**0 * 10**9` (= 1,000,000,000) | Gwei |
| `EJECTION_BALANCE` | `2**4 * 10**9` (= 16,000,000,000) | Gwei |
+| `HIGH_BALANCE_INCREMENT` | `2**0 * 10**9` (= 1,000,000,000) | Gwei |
### Initial values
| Name | Value |
| - | - |
-| `GENESIS_FORK_VERSION` | `0` |
+| `GENESIS_FORK_VERSION` | `int_to_bytes4(0)` |
| `GENESIS_SLOT` | `2**32` |
| `GENESIS_EPOCH` | `slot_to_epoch(GENESIS_SLOT)` |
| `GENESIS_START_SHARD` | `0` |
@@ -232,6 +235,10 @@ Code snippets appearing in `this style` are to be interpreted as Python code.
| `SLOTS_PER_HISTORICAL_ROOT` | `2**13` (= 8,192) | slots | ~13 hours |
| `MIN_VALIDATOR_WITHDRAWABILITY_DELAY` | `2**8` (= 256) | epochs | ~27 hours |
| `PERSISTENT_COMMITTEE_PERIOD` | `2**11` (= 2,048) | epochs | 9 days |
+| `MAX_CROSSLINK_EPOCHS` | `2**6` (= 64) |
+
+* `MAX_CROSSLINK_EPOCHS` should be a small constant times `SHARD_COUNT // SLOTS_PER_EPOCH`
+
### State list lengths
@@ -246,13 +253,13 @@ 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)`.
+* 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
@@ -315,6 +322,8 @@ The types are defined topologically to aid in facilitating an executable version
{
# Root of the deposit tree
'deposit_root': 'bytes32',
+ # Total number of deposits
+ 'deposit_count': 'uint64',
# Block hash
'block_hash': 'bytes32',
}
@@ -362,44 +371,32 @@ The types are defined topologically to aid in facilitating an executable version
}
```
-#### `SlashableAttestation`
+#### `IndexedAttestation`
```python
{
# Validator indices
- 'validator_indices': ['uint64'],
+ 'custody_bit_0_indices': ['uint64'],
+ 'custody_bit_1_indices': ['uint64'],
# Attestation data
'data': AttestationData,
- # Custody bitfield
- 'custody_bitfield': 'bytes',
# Aggregate signature
'aggregate_signature': 'bytes96',
}
```
-#### `DepositInput`
-
-```python
-{
- # BLS pubkey
- 'pubkey': 'bytes48',
- # Withdrawal credentials
- 'withdrawal_credentials': 'bytes32',
- # A BLS signature of this `DepositInput`
- 'proof_of_possession': 'bytes96',
-}
-```
-
#### `DepositData`
```python
{
+ # BLS pubkey
+ 'pubkey': 'bytes48',
+ # Withdrawal credentials
+ 'withdrawal_credentials': 'bytes32',
# Amount in Gwei
'amount': 'uint64',
- # Timestamp from deposit contract
- 'timestamp': 'uint64',
- # Deposit input
- 'deposit_input': DepositInput,
+ # Container self-signature
+ 'proof_of_possession': 'bytes96',
}
```
@@ -414,7 +411,6 @@ The types are defined topologically to aid in facilitating an executable version
'signature': 'bytes96',
}
```
-
#### `Validator`
```python
@@ -433,6 +429,8 @@ The types are defined topologically to aid in facilitating an executable version
'initiated_exit': 'bool',
# Was the validator slashed
'slashed': 'bool',
+ # Rounded balance
+ 'high_balance': 'uint64'
}
```
@@ -481,10 +479,10 @@ The types are defined topologically to aid in facilitating an executable version
```python
{
- # First slashable attestation
- 'slashable_attestation_1': SlashableAttestation,
- # Second slashable attestation
- 'slashable_attestation_2': SlashableAttestation,
+ # First attestation
+ 'attestation_1': IndexedAttestation,
+ # Second attestation
+ 'attestation_2': IndexedAttestation,
}
```
@@ -512,7 +510,7 @@ The types are defined topologically to aid in facilitating an executable version
# Index in the deposit tree
'index': 'uint64',
# Data
- 'deposit_data': DepositData,
+ 'data': DepositData,
}
```
@@ -593,17 +591,12 @@ The types are defined topologically to aid in facilitating an executable version
# Validator registry
'validator_registry': [Validator],
- 'validator_balances': ['uint64'],
+ 'balances': ['uint64'],
'validator_registry_update_epoch': 'uint64',
# Randomness and committees
'latest_randao_mixes': ['bytes32', LATEST_RANDAO_MIXES_LENGTH],
- 'previous_shuffling_start_shard': 'uint64',
- 'current_shuffling_start_shard': 'uint64',
- 'previous_shuffling_epoch': 'uint64',
- 'current_shuffling_epoch': 'uint64',
- 'previous_shuffling_seed': 'bytes32',
- 'current_shuffling_seed': 'bytes32',
+ 'latest_start_shard': 'uint64',
# Finality
'previous_epoch_attestations': [PendingAttestation],
@@ -628,7 +621,7 @@ The types are defined topologically to aid in facilitating an executable version
# Ethereum 1.0 chain data
'latest_eth1_data': Eth1Data,
'eth1_data_votes': [Eth1DataVote],
- 'deposit_index': 'uint64'
+ 'deposit_index': 'uint64',
}
```
@@ -660,7 +653,7 @@ def xor(bytes1: Bytes32, bytes2: Bytes32) -> Bytes32:
### `hash`
-The hash function is denoted by `hash`. In Phase 0 the beacon chain is deployed with the same hash function as Ethereum 1.0, i.e. Keccak-256 (also incorrectly known as SHA3).
+The `hash` function is SHA256.
Note: We aim to migrate to a S[T/N]ARK-friendly hash function in a future Ethereum 2.0 deployment phase.
@@ -684,7 +677,8 @@ def get_temporary_block_header(block: BeaconBlock) -> BeaconBlockHeader:
previous_block_root=block.previous_block_root,
state_root=ZERO_HASH,
block_body_root=hash_tree_root(block.body),
- signature=block.signature,
+ # signed_root(block) is used for block id purposes so signature is a stub
+ signature=EMPTY_SIGNATURE,
)
```
@@ -737,6 +731,18 @@ def is_active_validator(validator: Validator, epoch: Epoch) -> bool:
return validator.activation_epoch <= epoch < validator.exit_epoch
```
+### `is_slashable_validator`
+```python
+def is_slashable_validator(validator: Validator, epoch: Epoch) -> bool:
+ """
+ Check if ``validator`` is slashable.
+ """
+ return (
+ validator.activation_epoch <= epoch < validator.withdrawable_epoch and
+ validator.slashed is False
+ )
+```
+
### `get_active_validator_indices`
```python
@@ -747,12 +753,59 @@ def get_active_validator_indices(validators: List[Validator], epoch: Epoch) -> L
return [i for i, v in enumerate(validators) if is_active_validator(v, epoch)]
```
+### `get_balance`
+
+```python
+def get_balance(state: BeaconState, index: ValidatorIndex) -> Gwei:
+ """
+ Return the balance for a validator with the given ``index``.
+ """
+ return state.balances[index]
+```
+
+### `set_balance`
+
+```python
+def set_balance(state: BeaconState, index: ValidatorIndex, balance: Gwei) -> None:
+ """
+ Set the balance for a validator with the given ``index`` in both ``BeaconState``
+ and validator's rounded balance ``high_balance``.
+ """
+ validator = state.validator_registry[index]
+ HALF_INCREMENT = HIGH_BALANCE_INCREMENT // 2
+ if validator.high_balance > balance or validator.high_balance + 3 * HALF_INCREMENT < balance:
+ validator.high_balance = balance - balance % HIGH_BALANCE_INCREMENT
+ state.balances[index] = balance
+```
+
+### `increase_balance`
+
+```python
+def increase_balance(state: BeaconState, index: ValidatorIndex, delta: Gwei) -> None:
+ """
+ Increase the balance for a validator with the given ``index`` by ``delta``.
+ """
+ set_balance(state, index, get_balance(state, index) + delta)
+```
+
+### `decrease_balance`
+
+```python
+def decrease_balance(state: BeaconState, index: ValidatorIndex, delta: Gwei) -> None:
+ """
+ Decrease the balance for a validator with the given ``index`` by ``delta``.
+ Set to ``0`` when underflow.
+ """
+ current_balance = get_balance(state, index)
+ set_balance(state, index, current_balance - delta if current_balance >= delta else 0)
+```
+
### `get_permuted_index`
```python
def get_permuted_index(index: int, list_size: int, seed: Bytes32) -> int:
"""
- Return `p(index)` in a pseudorandom permutation `p` of `0...list_size-1` with ``seed`` as entropy.
+ Return `p(index)` in a pseudorandom permutation `p` of `0...list_size - 1` with ``seed`` as entropy.
Utilizes 'swap or not' shuffling found in
https://link.springer.com/content/pdf/10.1007%2F978-3-642-32009-5_1.pdf
@@ -773,18 +826,15 @@ def get_permuted_index(index: int, list_size: int, seed: Bytes32) -> int:
return index
```
-### `split`
+### `get_split_offset`
```python
-def split(values: List[Any], split_count: int) -> List[List[Any]]:
- """
- Splits ``values`` into ``split_count`` pieces.
- """
- list_length = len(values)
- return [
- values[(list_length * i // split_count): (list_length * (i + 1) // split_count)]
- for i in range(split_count)
- ]
+def get_split_offset(list_size: int, chunks: int, index: int) -> int:
+ """
+ Returns a value such that for a list L, chunk count k and index i,
+ split(L, k)[i] == L[get_split_offset(len(L), k, i): get_split_offset(len(L), k, i+1)]
+ """
+ return (list_size * index) // chunks
```
### `get_epoch_committee_count`
@@ -803,42 +853,26 @@ def get_epoch_committee_count(active_validator_count: int) -> int:
) * SLOTS_PER_EPOCH
```
-### `get_shuffling`
+### `compute_committee`
```python
-def get_shuffling(seed: Bytes32,
- validators: List[Validator],
- epoch: Epoch) -> List[List[ValidatorIndex]]:
+def compute_committee(validator_indices: List[ValidatorIndex],
+ seed: Bytes32,
+ index: int,
+ total_committees: int) -> List[ValidatorIndex]:
"""
- Shuffle active validators and split into crosslink committees.
- Return a list of committees (each a list of validator indices).
+ Return the ``index``'th shuffled committee out of a total ``total_committees``
+ using ``validator_indices`` and ``seed``.
"""
- # Shuffle active validator indices
- active_validator_indices = get_active_validator_indices(validators, epoch)
- length = len(active_validator_indices)
- shuffled_indices = [active_validator_indices[get_permuted_index(i, length, seed)] for i in range(length)]
-
- # Split the shuffled active validator indices
- return split(shuffled_indices, get_epoch_committee_count(length))
+ start_offset = get_split_offset(len(validator_indices), total_committees, index)
+ end_offset = get_split_offset(len(validator_indices), total_committees, index + 1)
+ return [
+ validator_indices[get_permuted_index(i, len(validator_indices), seed)]
+ for i in range(start_offset, end_offset)
+ ]
```
-**Invariant**: if `get_shuffling(seed, validators, epoch)` returns some value `x` for some `epoch <= get_current_epoch(state) + ACTIVATION_EXIT_DELAY`, it should return the same value `x` for the same `seed` and `epoch` and possible future modifications of `validators` forever in phase 0, and until the ~1 year deletion delay in phase 2 and in the future.
-
-**Note**: this definition and the next few definitions make heavy use of repetitive computing. Production implementations are expected to appropriately use caching/memoization to avoid redoing work.
-
-### `get_previous_epoch_committee_count`
-
-```python
-def get_previous_epoch_committee_count(state: BeaconState) -> int:
- """
- Return the number of committees in the previous epoch of the given ``state``.
- """
- previous_active_validators = get_active_validator_indices(
- state.validator_registry,
- state.previous_shuffling_epoch,
- )
- return get_epoch_committee_count(len(previous_active_validators))
-```
+**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`
@@ -849,36 +883,18 @@ def get_current_epoch_committee_count(state: BeaconState) -> int:
"""
current_active_validators = get_active_validator_indices(
state.validator_registry,
- state.current_shuffling_epoch,
+ get_current_epoch(state),
)
return get_epoch_committee_count(len(current_active_validators))
```
-### `get_next_epoch_committee_count`
-
-```python
-def get_next_epoch_committee_count(state: BeaconState) -> int:
- """
- Return the number of committees in the next epoch of the given ``state``.
- """
- next_active_validators = get_active_validator_indices(
- state.validator_registry,
- get_current_epoch(state) + 1,
- )
- return get_epoch_committee_count(len(next_active_validators))
-```
-
### `get_crosslink_committees_at_slot`
```python
def get_crosslink_committees_at_slot(state: BeaconState,
- slot: Slot,
- registry_change: bool=False) -> List[Tuple[List[ValidatorIndex], Shard]]:
+ slot: Slot) -> List[Tuple[List[ValidatorIndex], Shard]]:
"""
Return the list of ``(committee, shard)`` tuples for the ``slot``.
-
- Note: There are two possible shufflings for crosslink committees for a
- ``slot`` in the next epoch -- with and without a `registry_change`
"""
epoch = slot_to_epoch(slot)
current_epoch = get_current_epoch(state)
@@ -886,48 +902,28 @@ def get_crosslink_committees_at_slot(state: BeaconState,
next_epoch = current_epoch + 1
assert previous_epoch <= epoch <= next_epoch
+ indices = get_active_validator_indices(
+ state.validator_registry,
+ epoch,
+ )
+ committees_per_epoch = get_epoch_committee_count(len(indices))
if epoch == current_epoch:
- committees_per_epoch = get_current_epoch_committee_count(state)
- seed = state.current_shuffling_seed
- shuffling_epoch = state.current_shuffling_epoch
- shuffling_start_shard = state.current_shuffling_start_shard
+ start_shard = state.latest_start_shard
elif epoch == previous_epoch:
- committees_per_epoch = get_previous_epoch_committee_count(state)
- seed = state.previous_shuffling_seed
- shuffling_epoch = state.previous_shuffling_epoch
- shuffling_start_shard = state.previous_shuffling_start_shard
+ start_shard = (state.latest_start_shard - committees_per_epoch) % SHARD_COUNT
elif epoch == next_epoch:
- epochs_since_last_registry_update = current_epoch - state.validator_registry_update_epoch
- if registry_change:
- committees_per_epoch = get_next_epoch_committee_count(state)
- seed = generate_seed(state, next_epoch)
- shuffling_epoch = next_epoch
- current_committees_per_epoch = get_current_epoch_committee_count(state)
- shuffling_start_shard = (state.current_shuffling_start_shard + current_committees_per_epoch) % SHARD_COUNT
- elif epochs_since_last_registry_update > 1 and is_power_of_two(epochs_since_last_registry_update):
- committees_per_epoch = get_next_epoch_committee_count(state)
- seed = generate_seed(state, next_epoch)
- shuffling_epoch = next_epoch
- shuffling_start_shard = state.current_shuffling_start_shard
- else:
- committees_per_epoch = get_current_epoch_committee_count(state)
- seed = state.current_shuffling_seed
- shuffling_epoch = state.current_shuffling_epoch
- shuffling_start_shard = state.current_shuffling_start_shard
+ current_epoch_committees = get_current_epoch_committee_count(state)
+ start_shard = (state.latest_start_shard + current_epoch_committees) % SHARD_COUNT
- shuffling = get_shuffling(
- seed,
- state.validator_registry,
- shuffling_epoch,
- )
- offset = slot % SLOTS_PER_EPOCH
committees_per_slot = committees_per_epoch // SLOTS_PER_EPOCH
- slot_start_shard = (shuffling_start_shard + committees_per_slot * offset) % SHARD_COUNT
+ offset = slot % SLOTS_PER_EPOCH
+ slot_start_shard = (start_shard + committees_per_slot * offset) % SHARD_COUNT
+ seed = generate_seed(state, epoch)
return [
(
- shuffling[committees_per_slot * offset + i],
+ compute_committee(indices, seed, committees_per_slot * offset + i, committees_per_epoch),
(slot_start_shard + i) % SHARD_COUNT,
)
for i in range(committees_per_slot)
@@ -1002,20 +998,26 @@ def generate_seed(state: BeaconState,
```python
def get_beacon_proposer_index(state: BeaconState,
- slot: Slot,
- registry_change: bool=False) -> ValidatorIndex:
+ slot: Slot) -> ValidatorIndex:
"""
Return the beacon proposer index for the ``slot``.
+ Due to proposer selection being based upon the validator balances during
+ the epoch in question, this can only be run for the current epoch.
"""
- epoch = slot_to_epoch(slot)
current_epoch = get_current_epoch(state)
- previous_epoch = get_previous_epoch(state)
- next_epoch = current_epoch + 1
+ assert slot_to_epoch(slot) == current_epoch
- assert previous_epoch <= epoch <= next_epoch
-
- first_committee, _ = get_crosslink_committees_at_slot(state, slot, registry_change)[0]
- return first_committee[epoch % len(first_committee)]
+ first_committee, _ = get_crosslink_committees_at_slot(state, slot)[0]
+ i = 0
+ while True:
+ rand_byte = hash(
+ generate_seed(state, current_epoch) +
+ int_to_bytes8(i // 32)
+ )[i % 32]
+ candidate = first_committee[(current_epoch + i) % len(first_committee)]
+ if get_effective_balance(state, candidate) * 256 > MAX_DEPOSIT_AMOUNT * rand_byte:
+ return candidate
+ i += 1
```
### `verify_merkle_branch`
@@ -1035,6 +1037,20 @@ def verify_merkle_branch(leaf: Bytes32, proof: List[Bytes32], depth: int, index:
return value == root
```
+### `get_crosslink_committee_for_attestation`
+
+```python
+def get_crosslink_committee_for_attestation(state: BeaconState,
+ attestation_data: AttestationData) -> List[ValidatorIndex]:
+ # Find the committee in the list with the desired shard
+ crosslink_committees = get_crosslink_committees_at_slot(state, attestation_data.slot)
+
+ assert attestation_data.shard in [shard for _, shard in crosslink_committees]
+ crosslink_committee = [committee for committee, shard in crosslink_committees if shard == attestation_data.shard][0]
+
+ return crosslink_committee
+```
+
### `get_attestation_participants`
```python
@@ -1042,13 +1058,9 @@ def get_attestation_participants(state: BeaconState,
attestation_data: AttestationData,
bitfield: bytes) -> List[ValidatorIndex]:
"""
- Return the participant indices at for the ``attestation_data`` and ``bitfield``.
+ Return the sorted participant indices corresponding to ``attestation_data`` and ``bitfield``.
"""
- # Find the committee in the list with the desired shard
- crosslink_committees = get_crosslink_committees_at_slot(state, attestation_data.slot)
-
- assert attestation_data.shard in [shard for _, shard in crosslink_committees]
- crosslink_committee = [committee for committee, shard in crosslink_committees if shard == attestation_data.shard][0]
+ crosslink_committee = get_crosslink_committee_for_attestation(state, attestation_data)
assert verify_bitfield(bitfield, len(crosslink_committee))
@@ -1058,17 +1070,7 @@ def get_attestation_participants(state: BeaconState,
aggregation_bit = get_bitfield_bit(bitfield, i)
if aggregation_bit == 0b1:
participants.append(validator_index)
- return participants
-```
-
-### `is_power_of_two`
-
-```python
-def is_power_of_two(value: int) -> bool:
- """
- Check if ``value`` is a power of two integer.
- """
- return (value > 0) and (value & (value - 1) == 0)
+ return sorted(participants)
```
### `int_to_bytes1`, `int_to_bytes2`, ...
@@ -1089,7 +1091,7 @@ def get_effective_balance(state: BeaconState, index: ValidatorIndex) -> Gwei:
"""
Return the effective balance (also known as "balance at stake") for a validator with the given ``index``.
"""
- return min(state.validator_balances[index], MAX_DEPOSIT_AMOUNT)
+ return min(get_balance(state, index), MAX_DEPOSIT_AMOUNT)
```
### `get_total_balance`
@@ -1156,48 +1158,59 @@ def verify_bitfield(bitfield: bytes, committee_size: int) -> bool:
return True
```
-### `verify_slashable_attestation`
+### `convert_to_indexed`
```python
-def verify_slashable_attestation(state: BeaconState, slashable_attestation: SlashableAttestation) -> bool:
+def convert_to_indexed(state: BeaconState, attestation: Attestation):
"""
- Verify validity of ``slashable_attestation`` fields.
+ Convert an attestation to (almost) indexed-verifiable form
"""
- if slashable_attestation.custody_bitfield != b'\x00' * len(slashable_attestation.custody_bitfield): # [TO BE REMOVED IN PHASE 1]
+ attesting_indices = get_attestation_participants(state, attestation.data, attestation.aggregation_bitfield)
+ custody_bit_1_indices = get_attestation_participants(state, attestation.data, attestation.custody_bitfield)
+ custody_bit_0_indices = [index for index in attesting_indices if index not in custody_bit_1_indices]
+
+ return IndexedAttestation(
+ custody_bit_0_indices=custody_bit_0_indices,
+ custody_bit_1_indices=custody_bit_1_indices,
+ data=attestation.data,
+ aggregate_signature=attestation.aggregate_signature
+ )
+```
+
+### `verify_indexed_attestation`
+
+```python
+def verify_indexed_attestation(state: BeaconState, indexed_attestation: IndexedAttestation) -> bool:
+ """
+ Verify validity of ``indexed_attestation`` fields.
+ """
+ custody_bit_0_indices = indexed_attestation.custody_bit_0_indices
+ custody_bit_1_indices = indexed_attestation.custody_bit_1_indices
+
+ if len(custody_bit_1_indices) > 0: # [TO BE REMOVED IN PHASE 1]
return False
- if len(slashable_attestation.validator_indices) == 0:
+ total_attesting_indices = len(custody_bit_0_indices + custody_bit_1_indices)
+ if not (1 <= total_attesting_indices <= MAX_ATTESTATION_PARTICIPANTS):
return False
- for i in range(len(slashable_attestation.validator_indices) - 1):
- if slashable_attestation.validator_indices[i] >= slashable_attestation.validator_indices[i + 1]:
- return False
-
- if not verify_bitfield(slashable_attestation.custody_bitfield, len(slashable_attestation.validator_indices)):
+ if custody_bit_0_indices != sorted(custody_bit_0_indices):
return False
- if len(slashable_attestation.validator_indices) > MAX_INDICES_PER_SLASHABLE_VOTE:
+ if custody_bit_1_indices != sorted(custody_bit_1_indices):
return False
- custody_bit_0_indices = []
- custody_bit_1_indices = []
- for i, validator_index in enumerate(slashable_attestation.validator_indices):
- if get_bitfield_bit(slashable_attestation.custody_bitfield, i) == 0b0:
- custody_bit_0_indices.append(validator_index)
- else:
- custody_bit_1_indices.append(validator_index)
-
return bls_verify_multiple(
pubkeys=[
bls_aggregate_pubkeys([state.validator_registry[i].pubkey for i in custody_bit_0_indices]),
bls_aggregate_pubkeys([state.validator_registry[i].pubkey for i in custody_bit_1_indices]),
],
message_hashes=[
- hash_tree_root(AttestationDataAndCustodyBit(data=slashable_attestation.data, custody_bit=0b0)),
- hash_tree_root(AttestationDataAndCustodyBit(data=slashable_attestation.data, custody_bit=0b1)),
+ hash_tree_root(AttestationDataAndCustodyBit(data=indexed_attestation.data, custody_bit=0b0)),
+ hash_tree_root(AttestationDataAndCustodyBit(data=indexed_attestation.data, custody_bit=0b1)),
],
- signature=slashable_attestation.aggregate_signature,
- domain=get_domain(state.fork, slot_to_epoch(slashable_attestation.data.slot), DOMAIN_ATTESTATION),
+ signature=indexed_attestation.aggregate_signature,
+ domain=get_domain(state.fork, slot_to_epoch(indexed_attestation.data.slot), DOMAIN_ATTESTATION),
)
```
@@ -1278,19 +1291,12 @@ def process_deposit(state: BeaconState, deposit: Deposit) -> None:
Process a deposit from Ethereum 1.0.
Note that this function mutates ``state``.
"""
- deposit_input = deposit.deposit_data.deposit_input
-
- # Should equal 8 bytes for deposit_data.amount +
- # 8 bytes for deposit_data.timestamp +
- # 176 bytes for deposit_data.deposit_input
- # It should match the deposit_data in the eth1.0 deposit contract
- serialized_deposit_data = serialize(deposit.deposit_data)
# Deposits must be processed in order
assert deposit.index == state.deposit_index
# Verify the Merkle branch
merkle_branch_is_valid = verify_merkle_branch(
- leaf=hash(serialized_deposit_data),
+ leaf=hash(serialize(deposit.data)), # 48 + 32 + 8 + 96 = 184 bytes serialization
proof=deposit.proof,
depth=DEPOSIT_CONTRACT_TREE_DEPTH,
index=deposit.index,
@@ -1305,16 +1311,15 @@ def process_deposit(state: BeaconState, deposit: Deposit) -> None:
state.deposit_index += 1
validator_pubkeys = [v.pubkey for v in state.validator_registry]
- pubkey = deposit_input.pubkey
- amount = deposit.deposit_data.amount
- withdrawal_credentials = deposit_input.withdrawal_credentials
+ pubkey = deposit.data.pubkey
+ amount = deposit.data.amount
if pubkey not in validator_pubkeys:
# Verify the proof of possession
proof_is_valid = bls_verify(
- pubkey=deposit_input.pubkey,
- message_hash=signed_root(deposit_input),
- signature=deposit_input.proof_of_possession,
+ pubkey=pubkey,
+ message_hash=signed_root(deposit.data),
+ signature=deposit.data.proof_of_possession,
domain=get_domain(
state.fork,
get_current_epoch(state),
@@ -1327,20 +1332,23 @@ def process_deposit(state: BeaconState, deposit: Deposit) -> None:
# Add new validator
validator = Validator(
pubkey=pubkey,
- withdrawal_credentials=withdrawal_credentials,
+ withdrawal_credentials=deposit.data.withdrawal_credentials,
activation_epoch=FAR_FUTURE_EPOCH,
exit_epoch=FAR_FUTURE_EPOCH,
withdrawable_epoch=FAR_FUTURE_EPOCH,
initiated_exit=False,
slashed=False,
+ high_balance=0
)
# Note: In phase 2 registry indices that have been withdrawn for a long time will be recycled.
state.validator_registry.append(validator)
- state.validator_balances.append(amount)
+ state.balances.append(0)
+ set_balance(state, len(state.validator_registry) - 1, amount)
else:
# Increase balance by deposit amount
- state.validator_balances[validator_pubkeys.index(pubkey)] += amount
+ index = validator_pubkeys.index(pubkey)
+ increase_balance(state, index, amount)
```
### Routines for updating validator status
@@ -1377,38 +1385,38 @@ def initiate_validator_exit(state: BeaconState, index: ValidatorIndex) -> None:
```python
def exit_validator(state: BeaconState, index: ValidatorIndex) -> None:
"""
- Exit the validator of the given ``index``.
+ Exit the validator with the given ``index``.
Note that this function mutates ``state``.
"""
validator = state.validator_registry[index]
- delayed_activation_exit_epoch = get_delayed_activation_exit_epoch(get_current_epoch(state))
- # The following updates only occur if not previous exited
- if validator.exit_epoch <= delayed_activation_exit_epoch:
- return
- else:
- validator.exit_epoch = delayed_activation_exit_epoch
+ # Update validator exit epoch if not previously exited
+ if validator.exit_epoch == FAR_FUTURE_EPOCH:
+ validator.exit_epoch = get_delayed_activation_exit_epoch(get_current_epoch(state))
```
#### `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]
- assert state.slot < get_epoch_start_slot(validator.withdrawable_epoch) # [TO BE REMOVED IN PHASE 2]
- 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
- state.validator_balances[whistleblower_index] += whistleblower_reward
- state.validator_balances[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`
@@ -1430,11 +1438,11 @@ The initial deployment phases of Ethereum 2.0 are implemented without consensus
### Deposit arguments
-The deposit contract has a single `deposit` function which takes as argument a SimpleSerialize'd `DepositInput`.
+The deposit contract has a single `deposit` function which takes as argument a SimpleSerialize'd `DepositData`.
### Withdrawal credentials
-One of the `DepositInput` fields is `withdrawal_credentials`. It is a commitment to credentials for withdrawals to shards. The first byte of `withdrawal_credentials` is a version number. As of now the only expected format is as follows:
+One of the `DepositData` fields is `withdrawal_credentials`. It is a commitment to credentials for withdrawals to shards. The first byte of `withdrawal_credentials` is a version number. As of now the only expected format is as follows:
* `withdrawal_credentials[:1] == BLS_WITHDRAWAL_PREFIX_BYTE`
* `withdrawal_credentials[1:] == hash(withdrawal_pubkey)[1:]` where `withdrawal_pubkey` is a BLS pubkey
@@ -1447,10 +1455,11 @@ 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
+* `latest_eth1_data.deposit_count` equals `deposit_count` in the `Eth2Genesis` log
* `latest_eth1_data.block_hash` equals the hash of the block that included the log
* `genesis_validator_deposits` is a list of `Deposit` objects built according to the `Deposit` logs up to the deposit that triggered the `Eth2Genesis` log, processed in the order in which they were emitted (oldest to newest)
@@ -1474,6 +1483,7 @@ When enough full deposits have been made to the deposit contract, an `Eth2Genesi
* Let `genesis_time` be the timestamp specified in the `Eth2Genesis` log.
* Let `genesis_eth1_data` be the `Eth1Data` object where:
* `genesis_eth1_data.deposit_root` is the `deposit_root` contained in the `Eth2Genesis` log.
+ * `genesis_eth1_data.deposit_count` is the `deposit_count` contained in the `Eth2Genesis` log.
* `genesis_eth1_data.block_hash` is the hash of the Ethereum 1.0 block that emitted the `Eth2Genesis` log.
* Let `genesis_state = get_genesis_beacon_state(genesis_validator_deposits, genesis_time, genesis_eth1_data)`.
* Let `genesis_block = get_empty_block()`.
@@ -1492,6 +1502,7 @@ def get_empty_block() -> BeaconBlock:
randao_reveal=EMPTY_SIGNATURE,
eth1_data=Eth1Data(
deposit_root=ZERO_HASH,
+ deposit_count=0,
block_hash=ZERO_HASH,
),
proposer_slashings=[],
@@ -1517,29 +1528,24 @@ def get_genesis_beacon_state(genesis_validator_deposits: List[Deposit],
slot=GENESIS_SLOT,
genesis_time=genesis_time,
fork=Fork(
- previous_version=int_to_bytes4(GENESIS_FORK_VERSION),
- current_version=int_to_bytes4(GENESIS_FORK_VERSION),
+ previous_version=GENESIS_FORK_VERSION,
+ current_version=GENESIS_FORK_VERSION,
epoch=GENESIS_EPOCH,
),
# Validator registry
validator_registry=[],
- validator_balances=[],
+ balances=[],
validator_registry_update_epoch=GENESIS_EPOCH,
# Randomness and committees
- latest_randao_mixes=[ZERO_HASH for _ in range(LATEST_RANDAO_MIXES_LENGTH)],
- previous_shuffling_start_shard=GENESIS_START_SHARD,
- current_shuffling_start_shard=GENESIS_START_SHARD,
- previous_shuffling_epoch=GENESIS_EPOCH,
- current_shuffling_epoch=GENESIS_EPOCH,
- previous_shuffling_seed=ZERO_HASH,
- current_shuffling_seed=ZERO_HASH,
+ latest_randao_mixes=Vector([ZERO_HASH for _ in range(LATEST_RANDAO_MIXES_LENGTH)]),
+ latest_start_shard=GENESIS_START_SHARD,
# Finality
previous_epoch_attestations=[],
current_epoch_attestations=[],
- previous_justified_epoch=GENESIS_EPOCH,
+ previous_justified_epoch=GENESIS_EPOCH - 1,
current_justified_epoch=GENESIS_EPOCH,
previous_justified_root=ZERO_HASH,
current_justified_root=ZERO_HASH,
@@ -1548,11 +1554,11 @@ def get_genesis_beacon_state(genesis_validator_deposits: List[Deposit],
finalized_root=ZERO_HASH,
# Recent state
- latest_crosslinks=[Crosslink(epoch=GENESIS_EPOCH, crosslink_data_root=ZERO_HASH) for _ in range(SHARD_COUNT)],
- latest_block_roots=[ZERO_HASH for _ in range(SLOTS_PER_HISTORICAL_ROOT)],
- latest_state_roots=[ZERO_HASH for _ in range(SLOTS_PER_HISTORICAL_ROOT)],
- latest_active_index_roots=[ZERO_HASH for _ in range(LATEST_ACTIVE_INDEX_ROOTS_LENGTH)],
- latest_slashed_balances=[0 for _ in range(LATEST_SLASHED_EXIT_LENGTH)],
+ latest_crosslinks=Vector([Crosslink(epoch=GENESIS_EPOCH, crosslink_data_root=ZERO_HASH) for _ in range(SHARD_COUNT)]),
+ latest_block_roots=Vector([ZERO_HASH for _ in range(SLOTS_PER_HISTORICAL_ROOT)]),
+ latest_state_roots=Vector([ZERO_HASH for _ in range(SLOTS_PER_HISTORICAL_ROOT)]),
+ latest_active_index_roots=Vector([ZERO_HASH for _ in range(LATEST_ACTIVE_INDEX_ROOTS_LENGTH)]),
+ latest_slashed_balances=Vector([0 for _ in range(LATEST_SLASHED_EXIT_LENGTH)]),
latest_block_header=get_temporary_block_header(get_empty_block()),
historical_roots=[],
@@ -1574,20 +1580,19 @@ def get_genesis_beacon_state(genesis_validator_deposits: List[Deposit],
genesis_active_index_root = hash_tree_root(get_active_validator_indices(state.validator_registry, GENESIS_EPOCH))
for index in range(LATEST_ACTIVE_INDEX_ROOTS_LENGTH):
state.latest_active_index_roots[index] = genesis_active_index_root
- state.current_shuffling_seed = generate_seed(state, GENESIS_EPOCH)
return state
```
## 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:
@@ -1597,7 +1602,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
@@ -1639,9 +1644,12 @@ def lmd_ghost(store: Store, start_state: BeaconState, start_block: BeaconBlock)
for validator_index in active_validator_indices
]
+ # Use the rounded-balance-with-hysteresis supplied by the protocol for fork
+ # choice voting. This reduces the number of recomputations that need to be
+ # made for optimized implementations that precompute and save data
def get_vote_count(block: BeaconBlock) -> int:
return sum(
- get_effective_balance(start_state.validator_balances[validator_index]) // FORK_CHOICE_BALANCE_INCREMENT
+ start_state.validator_registry[validator_index].high_balance
for validator_index, target in attestation_targets
if get_ancestor(store, target, block.slot) == block
)
@@ -1656,7 +1664,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.
@@ -1664,7 +1672,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`.
@@ -1689,7 +1697,7 @@ def cache_state(state: BeaconState) -> None:
state.latest_block_header.state_root = previous_slot_state_root
# store latest known block for previous slot
- state.latest_block_roots[state.slot % SLOTS_PER_HISTORICAL_ROOT] = hash_tree_root(state.latest_block_header)
+ state.latest_block_roots[state.slot % SLOTS_PER_HISTORICAL_ROOT] = signed_root(state.latest_block_header)
```
### Per-epoch processing
@@ -1719,7 +1727,7 @@ def get_attesting_indices(state: BeaconState, attestations: List[PendingAttestat
```
```python
-def get_attesting_balance(state: BeaconState, attestations: List[PendingAttestation]) -> List[ValidatorIndex]:
+def get_attesting_balance(state: BeaconState, attestations: List[PendingAttestation]) -> Gwei:
return get_total_balance(state, get_attesting_indices(state, attestations))
```
@@ -1846,7 +1854,7 @@ Run the following function:
```python
def process_crosslinks(state: BeaconState) -> None:
current_epoch = get_current_epoch(state)
- previous_epoch = current_epoch - 1
+ previous_epoch = max(current_epoch - 1, GENESIS_EPOCH)
next_epoch = current_epoch + 1
for slot in range(get_epoch_start_slot(previous_epoch), get_epoch_start_slot(next_epoch)):
for crosslink_committee, shard in get_crosslink_committees_at_slot(state, slot):
@@ -1855,7 +1863,7 @@ def process_crosslinks(state: BeaconState) -> None:
total_balance = get_total_balance(state, crosslink_committee)
if 3 * participating_balance >= 2 * total_balance:
state.latest_crosslinks[shard] = Crosslink(
- epoch=slot_to_epoch(slot),
+ epoch=min(slot_to_epoch(slot), state.latest_crosslinks[shard].epoch + MAX_CROSSLINK_EPOCHS),
crosslink_data_root=winning_root
)
```
@@ -1890,35 +1898,23 @@ def get_base_reward(state: BeaconState, index: ValidatorIndex) -> Gwei:
```python
def get_inactivity_penalty(state: BeaconState, index: ValidatorIndex, epochs_since_finality: int) -> Gwei:
- return (
- get_base_reward(state, index) +
- get_effective_balance(state, index) * epochs_since_finality // INACTIVITY_PENALTY_QUOTIENT // 2
- )
+ if epochs_since_finality <= 4:
+ extra_penalty = 0
+ else:
+ extra_penalty = get_effective_balance(state, index) * epochs_since_finality // INACTIVITY_PENALTY_QUOTIENT // 2
+ 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
```python
def get_justification_and_finalization_deltas(state: BeaconState) -> Tuple[List[Gwei], List[Gwei]]:
- epochs_since_finality = get_current_epoch(state) + 1 - state.finalized_epoch
- if epochs_since_finality <= 4:
- return compute_normal_justification_and_finalization_deltas(state)
- else:
- return compute_inactivity_leak_deltas(state)
-```
-
-When blocks are finalizing normally...
-
-```python
-def compute_normal_justification_and_finalization_deltas(state: BeaconState) -> Tuple[List[Gwei], List[Gwei]]:
- # deltas[0] for rewards
- # deltas[1] for penalties
- deltas = [
- [0 for index in range(len(state.validator_registry))],
- [0 for index in range(len(state.validator_registry))]
- ]
+ current_epoch = get_current_epoch(state)
+ epochs_since_finality = current_epoch + 1 - state.finalized_epoch
+ rewards = [0 for index in range(len(state.validator_registry))]
+ penalties = [0 for index in range(len(state.validator_registry))]
# Some helper variables
boundary_attestations = get_previous_epoch_boundary_attestations(state)
boundary_attesting_balance = get_attesting_balance(state, boundary_attestations)
@@ -1926,88 +1922,52 @@ def compute_normal_justification_and_finalization_deltas(state: BeaconState) ->
total_attesting_balance = get_attesting_balance(state, state.previous_epoch_attestations)
matching_head_attestations = get_previous_epoch_matching_head_attestations(state)
matching_head_balance = get_attesting_balance(state, matching_head_attestations)
+ eligible_validators = [
+ index for index, validator in enumerate(state.validator_registry)
+ if (
+ is_active_validator(validator, current_epoch) or
+ (validator.slashed and current_epoch < validator.withdrawable_epoch)
+ )
+ ]
# Process rewards or penalties for all validators
- for index in get_active_validator_indices(state.validator_registry, get_previous_epoch(state)):
+ for index in eligible_validators:
+ base_reward = get_base_reward(state, index)
# Expected FFG source
if index in get_attesting_indices(state, state.previous_epoch_attestations):
- deltas[0][index] += get_base_reward(state, index) * total_attesting_balance // total_balance
+ rewards[index] += base_reward * total_attesting_balance // total_balance
# Inclusion speed bonus
- deltas[0][index] += (
- get_base_reward(state, index) * MIN_ATTESTATION_INCLUSION_DELAY //
+ rewards[index] += (
+ base_reward * MIN_ATTESTATION_INCLUSION_DELAY //
inclusion_distance(state, index)
)
else:
- deltas[1][index] += get_base_reward(state, index)
+ penalties[index] += base_reward
# Expected FFG target
if index in get_attesting_indices(state, boundary_attestations):
- deltas[0][index] += get_base_reward(state, index) * boundary_attesting_balance // total_balance
+ rewards[index] += base_reward * boundary_attesting_balance // total_balance
else:
- deltas[1][index] += get_base_reward(state, index)
+ penalties[index] += get_inactivity_penalty(state, index, epochs_since_finality)
# Expected head
if index in get_attesting_indices(state, matching_head_attestations):
- deltas[0][index] += get_base_reward(state, index) * matching_head_balance // total_balance
+ rewards[index] += base_reward * matching_head_balance // total_balance
else:
- deltas[1][index] += get_base_reward(state, index)
+ penalties[index] += base_reward
# Proposer bonus
if index in get_attesting_indices(state, state.previous_epoch_attestations):
proposer_index = get_beacon_proposer_index(state, inclusion_slot(state, index))
- deltas[0][proposer_index] += get_base_reward(state, index) // ATTESTATION_INCLUSION_REWARD_QUOTIENT
- return deltas
-```
-
-When blocks are not finalizing normally...
-
-```python
-def compute_inactivity_leak_deltas(state: BeaconState) -> Tuple[List[Gwei], List[Gwei]]:
- # deltas[0] for rewards
- # deltas[1] for penalties
- deltas = [
- [0 for index in range(len(state.validator_registry))],
- [0 for index in range(len(state.validator_registry))]
- ]
- boundary_attestations = get_previous_epoch_boundary_attestations(state)
- matching_head_attestations = get_previous_epoch_matching_head_attestations(state)
- active_validator_indices = get_active_validator_indices(state.validator_registry, get_previous_epoch(state))
- epochs_since_finality = get_current_epoch(state) + 1 - state.finalized_epoch
- for index in active_validator_indices:
- if index not in get_attesting_indices(state, state.previous_epoch_attestations):
- deltas[1][index] += get_inactivity_penalty(state, index, epochs_since_finality)
- else:
- # If a validator did attest, apply a small penalty for getting attestations included late
- deltas[0][index] += (
- get_base_reward(state, index) * MIN_ATTESTATION_INCLUSION_DELAY //
- inclusion_distance(state, index)
- )
- deltas[1][index] += get_base_reward(state, index)
- if index not in get_attesting_indices(state, boundary_attestations):
- deltas[1][index] += get_inactivity_penalty(state, index, epochs_since_finality)
- if index not in get_attesting_indices(state, matching_head_attestations):
- deltas[1][index] += get_base_reward(state, index)
- # Penalize slashed-but-inactive validators as though they were active but offline
- for index in range(len(state.validator_registry)):
- eligible = (
- index not in active_validator_indices and
- state.validator_registry[index].slashed and
- get_current_epoch(state) < state.validator_registry[index].withdrawable_epoch
- )
- if eligible:
- deltas[1][index] += (
- 2 * get_inactivity_penalty(state, index, epochs_since_finality) +
- get_base_reward(state, index)
- )
- return deltas
+ 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
+ return [rewards, penalties]
```
##### Crosslinks
```python
def get_crosslink_deltas(state: BeaconState) -> Tuple[List[Gwei], List[Gwei]]:
- # deltas[0] for rewards
- # deltas[1] for penalties
- deltas = [
- [0 for index in range(len(state.validator_registry))],
- [0 for index in range(len(state.validator_registry))]
- ]
+ rewards = [0 for index in range(len(state.validator_registry))]
+ penalties = [0 for index in range(len(state.validator_registry))]
previous_epoch_start_slot = get_epoch_start_slot(get_previous_epoch(state))
current_epoch_start_slot = get_epoch_start_slot(get_current_epoch(state))
for slot in range(previous_epoch_start_slot, current_epoch_start_slot):
@@ -2017,10 +1977,10 @@ def get_crosslink_deltas(state: BeaconState) -> Tuple[List[Gwei], List[Gwei]]:
total_balance = get_total_balance(state, crosslink_committee)
for index in crosslink_committee:
if index in participants:
- deltas[0][index] += get_base_reward(state, index) * participating_balance // total_balance
+ rewards[index] += get_base_reward(state, index) * participating_balance // total_balance
else:
- deltas[1][index] += get_base_reward(state, index)
- return deltas
+ penalties[index] += get_base_reward(state, index)
+ return [rewards, penalties]
```
#### Apply rewards
@@ -2029,12 +1989,16 @@ Run the following:
```python
def apply_rewards(state: BeaconState) -> None:
- deltas1 = get_justification_and_finalization_deltas(state)
- deltas2 = get_crosslink_deltas(state)
+ rewards1, penalties1 = get_justification_and_finalization_deltas(state)
+ rewards2, penalties2 = get_crosslink_deltas(state)
for i in range(len(state.validator_registry)):
- state.validator_balances[i] = max(
- 0,
- state.validator_balances[i] + deltas1[0][i] + deltas2[0][i] - deltas1[1][i] - deltas2[1][i]
+ set_balance(
+ state,
+ i,
+ max(
+ 0,
+ get_balance(state, i) + rewards1[i] + rewards2[i] - penalties1[i] - penalties2[i],
+ ),
)
```
@@ -2049,28 +2013,12 @@ def process_ejections(state: BeaconState) -> None:
and eject active validators with balance below ``EJECTION_BALANCE``.
"""
for index in get_active_validator_indices(state.validator_registry, get_current_epoch(state)):
- if state.validator_balances[index] < EJECTION_BALANCE:
- exit_validator(state, index)
+ if get_balance(state, index) < EJECTION_BALANCE:
+ initiate_validator_exit(state, index)
```
#### Validator registry and shuffling seed data
-```python
-def should_update_validator_registry(state: BeaconState) -> bool:
- # Must have finalized a new block
- if state.finalized_epoch <= state.validator_registry_update_epoch:
- return False
- # Must have processed new crosslinks on all shards of the current epoch
- shards_to_check = [
- (state.current_shuffling_start_shard + i) % SHARD_COUNT
- for i in range(get_current_epoch_committee_count(state))
- ]
- for shard in shards_to_check:
- if state.latest_crosslinks[shard].epoch <= state.validator_registry_update_epoch:
- return False
- return True
-```
-
```python
def update_validator_registry(state: BeaconState) -> None:
"""
@@ -2092,7 +2040,7 @@ def update_validator_registry(state: BeaconState) -> None:
# Activate validators within the allowable balance churn
balance_churn = 0
for index, validator in enumerate(state.validator_registry):
- if validator.activation_epoch == FAR_FUTURE_EPOCH and state.validator_balances[index] >= MAX_DEPOSIT_AMOUNT:
+ if validator.activation_epoch == FAR_FUTURE_EPOCH and get_balance(state, index) >= MAX_DEPOSIT_AMOUNT:
# Check the balance churn would be within the allowance
balance_churn += get_effective_balance(state, index)
if balance_churn > max_balance_churn:
@@ -2102,16 +2050,21 @@ def update_validator_registry(state: BeaconState) -> None:
activate_validator(state, index, is_genesis=False)
# Exit validators within the allowable balance churn
- balance_churn = 0
- for index, validator in enumerate(state.validator_registry):
- if validator.exit_epoch == FAR_FUTURE_EPOCH and validator.initiated_exit:
- # Check the balance churn would be within the allowance
- balance_churn += get_effective_balance(state, index)
- if balance_churn > max_balance_churn:
- break
+ if current_epoch < state.validator_registry_update_epoch + LATEST_SLASHED_EXIT_LENGTH:
+ balance_churn = (
+ state.latest_slashed_balances[state.validator_registry_update_epoch % LATEST_SLASHED_EXIT_LENGTH] -
+ state.latest_slashed_balances[current_epoch % LATEST_SLASHED_EXIT_LENGTH]
+ )
- # Exit validator
- exit_validator(state, index)
+ for index, validator in enumerate(state.validator_registry):
+ if validator.exit_epoch == FAR_FUTURE_EPOCH and validator.initiated_exit:
+ # Check the balance churn would be within the allowance
+ balance_churn += get_effective_balance(state, index)
+ if balance_churn > max_balance_churn:
+ break
+
+ # Exit validator
+ exit_validator(state, index)
state.validator_registry_update_epoch = current_epoch
```
@@ -2119,30 +2072,14 @@ def update_validator_registry(state: BeaconState) -> None:
Run the following function:
```python
-def update_registry_and_shuffling_data(state: BeaconState) -> None:
- # First set previous shuffling data to current shuffling data
- state.previous_shuffling_epoch = state.current_shuffling_epoch
- state.previous_shuffling_start_shard = state.current_shuffling_start_shard
- state.previous_shuffling_seed = state.current_shuffling_seed
- current_epoch = get_current_epoch(state)
- next_epoch = current_epoch + 1
+def update_registry(state: BeaconState) -> None:
# Check if we should update, and if so, update
- if should_update_validator_registry(state):
+ if state.finalized_epoch > state.validator_registry_update_epoch:
update_validator_registry(state)
- # If we update the registry, update the shuffling data and shards as well
- state.current_shuffling_epoch = next_epoch
- state.current_shuffling_start_shard = (
- state.current_shuffling_start_shard +
- get_current_epoch_committee_count(state) % SHARD_COUNT
- )
- state.current_shuffling_seed = generate_seed(state, state.current_shuffling_epoch)
- else:
- # If processing at least one crosslink keeps failing, then reshuffle every power of two,
- # but don't update the current_shuffling_start_shard
- epochs_since_last_registry_update = current_epoch - state.validator_registry_update_epoch
- if epochs_since_last_registry_update > 1 and is_power_of_two(epochs_since_last_registry_update):
- state.current_shuffling_epoch = next_epoch
- state.current_shuffling_seed = generate_seed(state, state.current_shuffling_epoch)
+ state.latest_start_shard = (
+ state.latest_start_shard +
+ get_current_epoch_committee_count(state)
+ ) % SHARD_COUNT
```
**Invariant**: the active index root that is hashed into the shuffling seed actually is the `hash_tree_root` of the validator set that is used for that epoch.
@@ -2172,7 +2109,7 @@ def process_slashings(state: BeaconState) -> None:
get_effective_balance(state, index) * min(total_penalties * 3, total_balance) // total_balance,
get_effective_balance(state, index) // MIN_PENALTY_QUOTIENT
)
- state.validator_balances[index] -= penalty
+ decrease_balance(state, index, penalty)
```
```python
@@ -2250,11 +2187,13 @@ def process_block_header(state: BeaconState, block: BeaconBlock) -> None:
# Verify that the slots match
assert block.slot == state.slot
# Verify that the parent matches
- assert block.previous_block_root == hash_tree_root(state.latest_block_header)
+ assert block.previous_block_root == signed_root(state.latest_block_header)
# Save current block as the new latest block
state.latest_block_header = get_temporary_block_header(block)
- # Verify proposer signature
+ # Verify proposer is not slashed
proposer = state.validator_registry[get_beacon_proposer_index(state, state.slot)]
+ assert not proposer.slashed
+ # Verify proposer signature
assert bls_verify(
pubkey=proposer.pubkey,
message_hash=signed_root(block),
@@ -2315,8 +2254,8 @@ def process_proposer_slashing(state: BeaconState,
assert slot_to_epoch(proposer_slashing.header_1.slot) == slot_to_epoch(proposer_slashing.header_2.slot)
# But the headers are different
assert proposer_slashing.header_1 != proposer_slashing.header_2
- # Proposer is not yet slashed
- assert proposer.slashed is False
+ # Check proposer is slashable
+ assert is_slashable_validator(proposer, get_current_epoch(state))
# Signatures are valid
for header in (proposer_slashing.header_1, proposer_slashing.header_2):
assert bls_verify(
@@ -2341,21 +2280,22 @@ def process_attester_slashing(state: BeaconState,
Process ``AttesterSlashing`` transaction.
Note that this function mutates ``state``.
"""
- attestation1 = attester_slashing.slashable_attestation_1
- attestation2 = attester_slashing.slashable_attestation_2
+ attestation1 = attester_slashing.attestation_1
+ attestation2 = attester_slashing.attestation_2
# Check that the attestations are conflicting
assert attestation1.data != attestation2.data
assert (
is_double_vote(attestation1.data, attestation2.data) or
is_surround_vote(attestation1.data, attestation2.data)
)
- assert verify_slashable_attestation(state, attestation1)
- assert verify_slashable_attestation(state, attestation2)
+
+ assert verify_indexed_attestation(state, attestation1)
+ assert verify_indexed_attestation(state, attestation2)
slashable_indices = [
index for index in attestation1.validator_indices
if (
index in attestation2.validator_indices and
- state.validator_registry[index].slashed is False
+ is_slashable_validator(state.validator_registry[index], get_current_epoch(state))
)
]
assert len(slashable_indices) >= 1
@@ -2375,80 +2315,46 @@ def process_attestation(state: BeaconState, attestation: Attestation) -> None:
Process ``Attestation`` transaction.
Note that this function mutates ``state``.
"""
- # Can't submit attestations that are too far in history (or in prehistory)
- assert attestation.data.slot >= GENESIS_SLOT
- assert state.slot <= attestation.data.slot + SLOTS_PER_EPOCH
- # Can't submit attestations too quickly
- assert attestation.data.slot + MIN_ATTESTATION_INCLUSION_DELAY <= state.slot
- # Verify that the justified epoch and root is correct
- if slot_to_epoch(attestation.data.slot) >= get_current_epoch(state):
- # Case 1: current epoch attestations
- assert attestation.data.source_epoch == state.current_justified_epoch
- assert attestation.data.source_root == state.current_justified_root
- else:
- # Case 2: previous epoch attestations
- assert attestation.data.source_epoch == state.previous_justified_epoch
- assert attestation.data.source_root == state.previous_justified_root
- # Check that the crosslink data is valid
- acceptable_crosslink_data = {
- # Case 1: Latest crosslink matches the one in the state
- attestation.data.previous_crosslink,
- # Case 2: State has already been updated, state's latest crosslink matches the crosslink
- # the attestation is trying to create
- Crosslink(
- crosslink_data_root=attestation.data.crosslink_data_root,
- epoch=slot_to_epoch(attestation.data.slot)
- )
- }
- assert state.latest_crosslinks[attestation.data.shard] in acceptable_crosslink_data
- # Attestation must be nonempty!
- assert attestation.aggregation_bitfield != b'\x00' * len(attestation.aggregation_bitfield)
- # Custody must be empty (to be removed in phase 1)
- assert attestation.custody_bitfield == b'\x00' * len(attestation.custody_bitfield)
- # Get the committee for the specific shard that this attestation is for
- crosslink_committee = [
- committee for committee, shard in get_crosslink_committees_at_slot(state, attestation.data.slot)
- if shard == attestation.data.shard
- ][0]
- # Custody bitfield must be a subset of the attestation bitfield
- for i in range(len(crosslink_committee)):
- if get_bitfield_bit(attestation.aggregation_bitfield, i) == 0b0:
- assert get_bitfield_bit(attestation.custody_bitfield, i) == 0b0
- # Verify aggregate signature
- participants = get_attestation_participants(state, attestation.data, attestation.aggregation_bitfield)
- custody_bit_1_participants = get_attestation_participants(state, attestation.data, attestation.custody_bitfield)
- custody_bit_0_participants = [i for i in participants if i not in custody_bit_1_participants]
+ assert max(GENESIS_SLOT, state.slot - SLOTS_PER_EPOCH) <= attestation.data.slot
+ assert attestation.data.slot <= state.slot - MIN_ATTESTATION_INCLUSION_DELAY
- assert bls_verify_multiple(
- pubkeys=[
- bls_aggregate_pubkeys([state.validator_registry[i].pubkey for i in custody_bit_0_participants]),
- bls_aggregate_pubkeys([state.validator_registry[i].pubkey for i in custody_bit_1_participants]),
- ],
- message_hashes=[
- hash_tree_root(AttestationDataAndCustodyBit(data=attestation.data, custody_bit=0b0)),
- hash_tree_root(AttestationDataAndCustodyBit(data=attestation.data, custody_bit=0b1)),
- ],
- signature=attestation.aggregate_signature,
- domain=get_domain(state.fork, slot_to_epoch(attestation.data.slot), DOMAIN_ATTESTATION),
- )
- # Crosslink data root is zero (to be removed in phase 1)
- assert attestation.data.crosslink_data_root == ZERO_HASH
- # Apply the attestation
+ # Check target epoch, source epoch, and source root
+ target_epoch = slot_to_epoch(attestation.data.slot)
+ assert (target_epoch, attestation.data.source_epoch, attestation.data.source_root) in {
+ (get_current_epoch(state), state.current_justified_epoch, state.current_justified_root),
+ (get_previous_epoch(state), state.previous_justified_epoch, state.previous_justified_root),
+ }
+
+ # Check crosslink data
+ assert attestation.data.crosslink_data_root == ZERO_HASH # [to be removed in phase 1]
+ assert state.latest_crosslinks[attestation.data.shard] in {
+ attestation.data.previous_crosslink, # Case 1: latest crosslink matches previous crosslink
+ Crosslink( # Case 2: latest crosslink matches current crosslink
+ crosslink_data_root=attestation.data.crosslink_data_root,
+ epoch=min(slot_to_epoch(attestation.data.slot),
+ attestation.data.previous_crosslink.epoch + MAX_CROSSLINK_EPOCHS)
+ ),
+ }
+
+ # Check signature and bitfields
+ assert verify_indexed_attestation(state, convert_to_indexed(state, attestation))
+
+ # Cache pending attestation
pending_attestation = PendingAttestation(
data=attestation.data,
aggregation_bitfield=attestation.aggregation_bitfield,
custody_bitfield=attestation.custody_bitfield,
inclusion_slot=state.slot
)
- if slot_to_epoch(attestation.data.slot) == get_current_epoch(state):
+ if target_epoch == get_current_epoch(state):
state.current_epoch_attestations.append(pending_attestation)
- elif slot_to_epoch(attestation.data.slot) == get_previous_epoch(state):
+ else:
state.previous_epoch_attestations.append(pending_attestation)
```
##### Deposits
-Verify that `len(block.body.deposits) <= MAX_DEPOSITS`.
+Verify that `len(block.body.deposits) == min(MAX_DEPOSITS, latest_eth1_data.deposit_count - state.deposit_index)`.
For each `deposit` in `block.body.deposits`, run `process_deposit(state, deposit)`.
@@ -2465,13 +2371,15 @@ def process_voluntary_exit(state: BeaconState, exit: VoluntaryExit) -> None:
Note that this function mutates ``state``.
"""
validator = state.validator_registry[exit.validator_index]
+ # Verify the validator is active
+ assert is_active_validator(validator, get_current_epoch(state))
# Verify the validator has not yet exited
assert validator.exit_epoch == FAR_FUTURE_EPOCH
# Verify the validator has not initiated an exit
assert validator.initiated_exit is False
# Exits must specify an epoch when they become valid; they are not valid before then
assert get_current_epoch(state) >= exit.epoch
- # Must have been in the validator set long enough
+ # Verify the validator has been active long enough
assert get_current_epoch(state) - validator.activation_epoch >= PERSISTENT_COMMITTEE_PERIOD
# Verify signature
assert bls_verify(
@@ -2480,7 +2388,7 @@ def process_voluntary_exit(state: BeaconState, exit: VoluntaryExit) -> None:
signature=exit.signature,
domain=get_domain(state.fork, exit.epoch, DOMAIN_VOLUNTARY_EXIT)
)
- # Run the exit
+ # Initiate exit
initiate_validator_exit(state, exit.validator_index)
```
@@ -2499,12 +2407,12 @@ def process_transfer(state: BeaconState, transfer: Transfer) -> None:
Note that this function mutates ``state``.
"""
# Verify the amount and fee aren't individually too big (for anti-overflow purposes)
- assert state.validator_balances[transfer.sender] >= max(transfer.amount, transfer.fee)
+ assert get_balance(state, transfer.sender) >= max(transfer.amount, transfer.fee)
# Verify that we have enough ETH to send, and that after the transfer the balance will be either
# exactly zero or at least MIN_DEPOSIT_AMOUNT
assert (
- state.validator_balances[transfer.sender] == transfer.amount + transfer.fee or
- state.validator_balances[transfer.sender] >= transfer.amount + transfer.fee + MIN_DEPOSIT_AMOUNT
+ get_balance(state, transfer.sender) == transfer.amount + transfer.fee or
+ get_balance(state, transfer.sender) >= transfer.amount + transfer.fee + MIN_DEPOSIT_AMOUNT
)
# A transfer is valid in only one slot
assert state.slot == transfer.slot
@@ -2526,9 +2434,9 @@ def process_transfer(state: BeaconState, transfer: Transfer) -> None:
domain=get_domain(state.fork, slot_to_epoch(transfer.slot), DOMAIN_TRANSFER)
)
# Process the transfer
- state.validator_balances[transfer.sender] -= transfer.amount + transfer.fee
- state.validator_balances[transfer.recipient] += transfer.amount
- state.validator_balances[get_beacon_proposer_index(state, state.slot)] += transfer.fee
+ decrease_balance(state, transfer.sender, transfer.amount + transfer.fee)
+ increase_balance(state, transfer.recipient, transfer.amount)
+ increase_balance(state, get_beacon_proposer_index(state, state.slot), transfer.fee)
```
#### State root verification
@@ -2542,7 +2450,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..fd754634e
--- /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 transactions per block](#max-transactions-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)
+ - [Transactions](#transactions)
+ - [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 transactions 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
+
+### Transactions
+
+Add the following transactions to the per-block processing, in order the given below and after all other transactions 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 db68591e7..8f2d12a91 100644
--- a/specs/core/1_shard-data-chains.md
+++ b/specs/core/1_shard-data-chains.md
@@ -1,167 +1,167 @@
# 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_split_offset`](#get_split_offset)
- - [`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)
- - [Data structures](#data-structures)
- - [`Validator`](#validator)
- - [`BeaconBlockBody`](#beaconblockbody)
- - [`BranchChallenge`](#branchchallenge)
- - [`BranchResponse`](#branchresponse)
- - [`BranchChallengeRecord`](#branchchallengerecord)
- - [`SubkeyReveal`](#subkeyreveal)
- - [Helpers](#helpers)
- - [`get_attestation_data_merkle_depth`](#get_attestation_data_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)
- - [`prepare_validator_for_withdrawal`](#prepare_validator_for_withdrawal)
- - [`penalize_validator`](#penalize_validator)
- - [Per-slot processing](#per-slot-processing)
- - [Operations](#operations)
- - [Branch challenges](#branch-challenges)
- - [Branch responses](#branch-responses)
- - [Subkey reveals](#subkey-reveals)
- - [Per-epoch processing](#per-epoch-processing)
- - [One-time phase 1 initiation transition](#one-time-phase-1-initiation-transition)
+- [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)
+ - [`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_split_offset`
-
-````python
-def get_split_offset(list_size: int, chunks: int, index: int) -> int:
- """
- Returns a value such that for a list L, chunk count k and index i,
- split(L, k)[i] == L[get_split_offset(len(L), k, i): get_split_offset(len(L), k+1, i)]
- """
- return (len(list_size) * index) // chunks
-````
-
-#### `get_shuffled_committee`
+### `get_period_committee`
```python
-def get_shuffled_committee(state: BeaconState,
- shard: Shard,
- committee_start_epoch: Epoch) -> 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.
"""
- validator_indices = get_active_validator_indices(state.validators, committee_start_epoch)
+ active_validator_indices = get_active_validator_indices(state.validator_registry, committee_start_epoch)
seed = generate_seed(state, committee_start_epoch)
- start_offset = get_split_offset(len(validator_indices), SHARD_COUNT, shard)
- end_offset = get_split_offset(len(validator_indices), SHARD_COUNT, shard + 1)
- return [
- validator_indices[get_permuted_index(i, len(validator_indices), seed)]
- for i in range(start_offset, end_offset)
- ]
+ return compute_committee(
+ validator_indices=active_validator_indices,
+ seed=seed,
+ index=shard * committee_count + index,
+ total_committees=SHARD_COUNT * committee_count,
+ )
```
-#### `get_persistent_committee`
+### `get_persistent_committee`
```python
def get_persistent_committee(state: BeaconState,
shard: Shard,
- epoch: Epoch) -> List[ValidatorIndex]:
+ slot: Slot) -> List[ValidatorIndex]:
"""
- Return the persistent committee for the given ``shard`` at the given ``epoch``.
+ Return the persistent committee for the given ``shard`` at the given ``slot``.
"""
- earlier_committee_start_epoch = epoch - (epoch % PERSISTENT_COMMITTEE_PERIOD) - PERSISTENT_COMMITTEE_PERIOD * 2
- earlier_committee = get_shuffled_committee(state, shard, earlier_committee_start_epoch)
+ earlier_start_epoch = epoch - (epoch % PERSISTENT_COMMITTEE_PERIOD) - PERSISTENT_COMMITTEE_PERIOD * 2
+ later_start_epoch = epoch - (epoch % PERSISTENT_COMMITTEE_PERIOD) - PERSISTENT_COMMITTEE_PERIOD
- later_committee_start_epoch = epoch - (epoch % PERSISTENT_COMMITTEE_PERIOD) - PERSISTENT_COMMITTEE_PERIOD
- later_committee = get_shuffled_committee(state, shard, later_committee_start_epoch)
+ committee_count = max(
+ len(get_active_validator_indices(state.validator_registry, earlier_start_epoch)) //
+ (SHARD_COUNT * TARGET_COMMITTEE_SIZE),
+ len(get_active_validator_indices(state.validator_registry, later_start_epoch)) //
+ (SHARD_COUNT * TARGET_COMMITTEE_SIZE),
+ ) + 1
+
+ index = slot % 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
@@ -170,723 +170,233 @@ def get_persistent_committee(state: BeaconState,
[i for i in later_committee if epoch % PERSISTENT_COMMITTEE_PERIOD >= get_switchover_epoch(i)]
)))
```
-#### `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)
- )
- persistent_committee = get_persistent_committee(state, shard, slot_to_epoch(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:
- if is_active_validator(state.validators[index], get_current_epoch(state)):
+ # Randomly shift persistent committee
+ persistent_committee = get_persistent_committee(state, shard, slot)
+ 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, slot_to_epoch(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.validators[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.validators[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, 'signature'),
- 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(challenge: BranchChallenge,
- state: BeaconState):
- # 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(response: BranchResponse,
- state: BeaconState):
- 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(response: BranchResponse,
- state: BeaconState):
- 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(initiation: InteractiveCustodyChallengeInitiation,
- state: BeaconState):
- 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(response: InteractiveCustodyChallengeResponse,
- state: State):
- 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(continuation: InteractiveCustodyChallengeContinuation,
- state: State):
- 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/specs/light_client/sync_protocol.md b/specs/light_client/sync_protocol.md
index a8cdd50c2..94ab8a2e4 100644
--- a/specs/light_client/sync_protocol.md
+++ b/specs/light_client/sync_protocol.md
@@ -1,8 +1,18 @@
-**NOTICE**: This document is a work-in-progress for researchers and implementers.
+# Beacon Chain Light Client Syncing
-# Beacon chain light client syncing
+__NOTICE__: This document is a work-in-progress for researchers and implementers. One of the design goals of the eth2 beacon chain is light-client friendlines, both to allow low-resource clients (mobile phones, IoT, etc) to maintain access to the blockchain in a reasonably safe way, but also to facilitate the development of "bridges" between the eth2 beacon chain and other chains.
+
+## Table of Contents
+
+
+- [Beacon Chain Light Client Syncing](#beacon-chain-light-client-syncing)
+ - [Table of Contents](#table-of-contents)
+ - [Light client state](#light-client-state)
+ - [Updating the shuffled committee](#updating-the-shuffled-committee)
+ - [Computing the current committee](#computing-the-current-committee)
+ - [Verifying blocks](#verifying-blocks)
+
-One of the design goals of the eth2 beacon chain is light-client friendlines, both to allow low-resource clients (mobile phones, IoT, etc) to maintain access to the blockchain in a reasonably safe way, but also to facilitate the development of "bridges" between the eth2 beacon chain and other chains.
### Preliminaries
@@ -112,6 +122,7 @@ def compute_committee(header: BeaconBlockHeader,
bytes_to_int(hash(validator_memory.earlier_period_data.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
return sorted(list(set(
@@ -158,4 +169,5 @@ def verify_block_validity_proof(proof: BlockValidityProof, validator_memory: Val
domain=get_domain(state, slot_to_epoch(shard_block.slot), DOMAIN_SHARD_ATTESTER)
)
```
+
The size of this proof is only 200 (header) + 96 (signature) + 16 (bitfield) + 352 (shard block) = 664 bytes. It can be reduced further by replacing `ShardBlock` with `MerklePartial(lambda x: x.beacon_chain_ref, ShardBlock)`, which would cut off ~220 bytes.
diff --git a/specs/networking/messaging.md b/specs/networking/messaging.md
new file mode 100644
index 000000000..b64e1d5d8
--- /dev/null
+++ b/specs/networking/messaging.md
@@ -0,0 +1,46 @@
+ETH 2.0 Networking Spec - Messaging
+===
+
+# Abstract
+
+This specification describes how individual Ethereum 2.0 messages are represented on the wire.
+
+The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL”, NOT", “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119.
+
+# Motivation
+
+This specification seeks to define a messaging protocol that is flexible enough to be changed easily as the ETH 2.0 specification evolves.
+
+Note that while `libp2p` is the chosen networking stack for Ethereum 2.0, as of this writing some clients do not have workable `libp2p` implementations. To allow those clients to communicate, we define a message envelope that includes the body's compression, encoding, and body length. Once `libp2p` is available across all implementations, this message envelope will be removed because `libp2p` will negotiate the values defined in the envelope upfront.
+
+# Specification
+
+## Message Structure
+
+An ETH 2.0 message consists of an envelope that defines the message's compression, encoding, and length followed by the body itself.
+
+Visually, a message looks like this:
+
+```
++--------------------------+
+| compression nibble |
++--------------------------+
+| encoding nibble |
++--------------------------+
+| body length (uint64) |
++--------------------------+
+| |
+| body |
+| |
++--------------------------+
+```
+
+Clients MUST ignore messages with mal-formed bodies. The compression/encoding nibbles MUST be one of the following values:
+
+## Compression Nibble Values
+
+- `0x0`: no compression
+
+## Encoding Nibble Values
+
+- `0x1`: SSZ
diff --git a/specs/networking/node-identification.md b/specs/networking/node-identification.md
new file mode 100644
index 000000000..0f1f9832b
--- /dev/null
+++ b/specs/networking/node-identification.md
@@ -0,0 +1,32 @@
+ETH 2.0 Networking Spec - Node Identification
+===
+
+# Abstract
+
+This specification describes how Ethereum 2.0 nodes identify and address each other on the network.
+
+The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL", NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119.
+
+# Specification
+
+Clients use Ethereum Node Records (as described in [EIP-778](http://eips.ethereum.org/EIPS/eip-778)) to discover one another. Each ENR includes, among other things, the following keys:
+
+- The node's IP.
+- The node's TCP port.
+- The node's public key.
+
+For clients to be addressable, their ENR responses MUST contain all of the above keys. Client MUST verify the signature of any received ENRs, and disconnect from peers whose ENR signatures are invalid. Each node's public key MUST be unique.
+
+The keys above are enough to construct a [multiaddr](https://github.com/multiformats/multiaddr) for use with the rest of the `libp2p` stack.
+
+It is RECOMMENDED that clients set their TCP port to the default of `9000`.
+
+## Peer ID Generation
+
+The `libp2p` networking stack identifies peers via a "peer ID." Simply put, a node's Peer ID is the SHA2-256 `multihash` of the node's public key struct (serialized in protobuf, refer to the [Peer ID spec](https://github.com/libp2p/specs/pull/100)). `go-libp2p-crypto` contains the canonical implementation of how to hash `secp256k1` keys for use as a peer ID.
+
+# See Also
+
+- [multiaddr](https://github.com/multiformats/multiaddr)
+- [multihash](https://multiformats.io/multihash/)
+- [go-libp2p-crypto](https://github.com/libp2p/go-libp2p-crypto)
diff --git a/specs/networking/rpc-interface.md b/specs/networking/rpc-interface.md
new file mode 100644
index 000000000..fa49bcd75
--- /dev/null
+++ b/specs/networking/rpc-interface.md
@@ -0,0 +1,292 @@
+ETH 2.0 Networking Spec - RPC Interface
+===
+
+# Abstract
+
+The Ethereum 2.0 networking stack uses two modes of communication: a broadcast protocol that gossips information to interested parties via GossipSub, and an RPC protocol that retrieves information from specific clients. This specification defines the RPC protocol.
+
+The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL", NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119.
+
+# Dependencies
+
+This specification assumes familiarity with the [Messaging](./messaging.md), [Node Identification](./node-identification), and [Beacon Chain](../core/0_beacon-chain.md) specifications.
+
+# Specification
+
+## Message Schemas
+
+Message body schemas are notated like this:
+
+```
+(
+ field_name_1: type
+ field_name_2: type
+)
+```
+
+Embedded types are serialized as SSZ Containers unless otherwise noted.
+
+All referenced data structures can be found in the [0-beacon-chain](https://github.com/ethereum/eth2.0-specs/blob/dev/specs/core/0_beacon-chain.md#data-structures) specification.
+
+## `libp2p` Protocol Names
+
+A "Protocol ID" in `libp2p` parlance refers to a human-readable identifier `libp2p` uses in order to identify sub-protocols and stream messages of different types over the same connection. Peers exchange supported protocol IDs via the `Identify` protocol upon connection. When opening a new stream, peers pin a particular protocol ID to it, and the stream remains contextualised thereafter. Since messages are sent inside a stream, they do not need to bear the protocol ID.
+
+## RPC-Over-`libp2p`
+
+To facilitate RPC-over-`libp2p`, a single protocol name is used: `/eth/serenity/beacon/rpc/1`. The version number in the protocol name is neither backwards or forwards compatible, and will be incremented whenever changes to the below structures are required.
+
+Remote method calls are wrapped in a "request" structure:
+
+```
+(
+ id: uint64
+ method_id: uint16
+ body: Request
+)
+```
+
+and their corresponding responses are wrapped in a "response" structure:
+
+```
+(
+ id: uint64
+ response_code: uint16
+ result: bytes
+)
+```
+
+If an error occurs, a variant of the response structure is returned:
+
+```
+(
+ id: uint64
+ response_code: uint16
+ result: bytes
+)
+```
+
+The details of the RPC-Over-`libp2p` protocol are similar to [JSON-RPC 2.0](https://www.jsonrpc.org/specification). Specifically:
+
+1. The `id` member is REQUIRED.
+2. The `id` member in the response MUST be the same as the value of the `id` in the request.
+3. The `id` member MUST be unique within the context of a single connection. Monotonically increasing `id`s are RECOMMENDED.
+4. The `method_id` member is REQUIRED.
+5. The `result` member is REQUIRED on success.
+6. The `result` member is OPTIONAL on errors, and MAY contain additional information about the error.
+7. `response_code` MUST be `0` on success.
+
+Structuring RPC requests in this manner allows multiple calls and responses to be multiplexed over the same stream without switching. Note that this implies that responses MAY arrive in a different order than requests.
+
+The "method ID" fields in the below messages refer to the `method` field in the request structure above.
+
+The first 1,000 values in `response_code` are reserved for system use. The following response codes are predefined:
+
+1. `0`: No error.
+2. `10`: Parse error.
+2. `20`: Invalid request.
+3. `30`: Method not found.
+4. `40`: Server error.
+
+### Alternative for Non-`libp2p` Clients
+
+Since some clients are waiting for `libp2p` implementations in their respective languages. As such, they MAY listen for raw TCP messages on port `9000`. To distinguish RPC messages from other messages on that port, a byte prefix of `ETH` (`0x455448`) MUST be prepended to all messages. This option will be removed once `libp2p` is ready in all supported languages.
+
+## Messages
+
+### Hello
+
+**Method ID:** `0`
+
+**Body**:
+
+```
+(
+ network_id: uint8
+ chain_id: uint64
+ latest_finalized_root: bytes32
+ latest_finalized_epoch: uint64
+ best_root: bytes32
+ best_slot: uint64
+)
+```
+
+Clients exchange `hello` messages upon connection, forming a two-phase handshake. The first message the initiating client sends MUST be the `hello` message. In response, the receiving client MUST respond with its own `hello` message.
+
+Clients SHOULD immediately disconnect from one another following the handshake above under the following conditions:
+
+1. If `network_id` belongs to a different chain, since the client definitionally cannot sync with this client.
+2. If the `latest_finalized_root` shared by the peer is not in the client's chain at the expected epoch. For example, if Peer 1 in the diagram below has `(root, epoch)` of `(A, 5)` and Peer 2 has `(B, 3)`, Peer 1 would disconnect because it knows that `B` is not the root in their chain at epoch 3:
+
+```
+ Root A
+
+ +---+
+ |xxx| +----+ Epoch 5
+ +-+-+
+ ^
+ |
+ +-+-+
+ | | +----+ Epoch 4
+ +-+-+
+Root B ^
+ |
++---+ +-+-+
+|xxx+<---+--->+ | +----+ Epoch 3
++---+ | +---+
+ |
+ +-+-+
+ | | +-----------+ Epoch 2
+ +-+-+
+ ^
+ |
+ +-+-+
+ | | +-----------+ Epoch 1
+ +---+
+```
+
+Once the handshake completes, the client with the higher `latest_finalized_epoch` or `best_slot` (if the clients have equal `latest_finalized_epoch`s) SHOULD request beacon block roots from its counterparty via `beacon_block_roots` (i.e., RPC method `10`).
+
+### Goodbye
+
+**Method ID:** `1`
+
+**Body:**
+
+```
+(
+ reason: uint64
+)
+```
+
+Client MAY send `goodbye` messages upon disconnection. The reason field MAY be one of the following values:
+
+- `1`: Client shut down.
+- `2`: Irrelevant network.
+- `3`: Fault/error.
+
+Clients MAY define custom goodbye reasons as long as the value is larger than `1000`.
+
+### Get Status
+
+**Method ID:** `2`
+
+**Request Body:**
+
+```
+(
+ sha: bytes32
+ user_agent: bytes
+ timestamp: uint64
+)
+```
+
+**Response Body:**
+
+```
+(
+ sha: bytes32
+ user_agent: bytes
+ timestamp: uint64
+)
+```
+
+Returns metadata about the remote node.
+
+### Request Beacon Block Roots
+
+**Method ID:** `10`
+
+**Request Body**
+
+```
+(
+ start_slot: uint64
+ count: uint64
+)
+```
+
+**Response Body:**
+
+```
+# BlockRootSlot
+(
+ block_root: bytes32
+ slot: uint64
+)
+
+(
+ roots: []BlockRootSlot
+)
+```
+
+Requests a list of block roots and slots from the peer. The `count` parameter MUST be less than or equal to `32768`. The slots MUST be returned in ascending slot order.
+
+### Beacon Block Headers
+
+**Method ID:** `11`
+
+**Request Body**
+
+```
+(
+ start_root: HashTreeRoot
+ start_slot: uint64
+ max_headers: uint64
+ skip_slots: uint64
+)
+```
+
+**Response Body:**
+
+```
+(
+ headers: []BeaconBlockHeader
+)
+```
+
+Requests beacon block headers from the peer starting from `(start_root, start_slot)`. The response MUST contain no more than `max_headers` headers. `skip_slots` defines the maximum number of slots to skip between blocks. For example, requesting blocks starting at slots `2` a `skip_slots` value of `1` would return the blocks at `[2, 4, 6, 8, 10]`. In cases where a slot is empty for a given slot number, the closest previous block MUST be returned. For example, if slot `4` were empty in the previous example, the returned array would contain `[2, 3, 6, 8, 10]`. If slot three were further empty, the array would contain `[2, 6, 8, 10]` - i.e., duplicate blocks MUST be collapsed. A `skip_slots` value of `0` returns all blocks.
+
+The function of the `skip_slots` parameter helps facilitate light client sync - for example, in [#459](https://github.com/ethereum/eth2.0-specs/issues/459) - and allows clients to balance the peers from whom they request headers. Clients could, for instance, request every 10th block from a set of peers where each per has a different starting block in order to populate block data.
+
+### Beacon Block Bodies
+
+**Method ID:** `12`
+
+**Request Body:**
+
+```
+(
+ block_roots: []HashTreeRoot
+)
+```
+
+**Response Body:**
+
+```
+(
+ block_bodies: []BeaconBlockBody
+)
+```
+
+Requests the `block_bodies` associated with the provided `block_roots` from the peer. Responses MUST return `block_roots` in the order provided in the request. If the receiver does not have a particular `block_root`, it must return a zero-value `block_body` (i.e., a `block_body` container with all zero fields).
+
+### Beacon Chain State
+
+**Note:** This section is preliminary, pending the definition of the data structures to be transferred over the wire during fast sync operations.
+
+**Method ID:** `13`
+
+**Request Body:**
+
+```
+(
+ hashes: []HashTreeRoot
+)
+```
+
+**Response Body:** TBD
+
+Requests contain the hashes of Merkle tree nodes that when merkelized yield the block's `state_root`.
+
+The response will contain the values that, when hashed, yield the hashes inside the request body.
diff --git a/specs/simple-serialize.md b/specs/simple-serialize.md
index 862d13edf..378a1a7cb 100644
--- a/specs/simple-serialize.md
+++ b/specs/simple-serialize.md
@@ -12,7 +12,7 @@ This is a **work in progress** describing typing, serialization and Merkleizatio
- [Serialization](#serialization)
- [`"uintN"`](#uintn)
- [`"bool"`](#bool)
- - [Tuples, containers, lists](#tuples-containers-lists)
+ - [Vectors, containers, lists](#vectors-containers-lists)
- [Deserialization](#deserialization)
- [Merkleization](#merkleization)
- [Self-signed containers](#self-signed-containers)
@@ -34,12 +34,14 @@ This is a **work in progress** describing typing, serialization and Merkleizatio
### Composite types
* **container**: ordered heterogenous collection of values
- * key-pair curly bracket notation `{}`, e.g. `{'foo': "uint64", 'bar': "bool"}`
-* **tuple**: ordered fixed-length homogeneous collection of values
+ * key-pair curly bracket notation `{}`, e.g. `{"foo": "uint64", "bar": "bool"}`
+* **vector**: ordered fixed-length homogeneous collection of values
* angle bracket notation `[type, N]`, e.g. `["uint64", N]`
* **list**: ordered variable-length homogenous collection of values
* angle bracket notation `[type]`, e.g. `["uint64"]`
+We recursively define "variable-size" types to be lists and all types that contains a variable-size type. All other types are said to be "fixed-size".
+
### Aliases
For convenience we alias:
@@ -54,34 +56,34 @@ We recursively define the `serialize` function which consumes an object `value`
*Note*: In the function definitions below (`serialize`, `hash_tree_root`, `signed_root`, etc.) objects implicitly carry their type.
-### `uintN`
+### `"uintN"`
```python
assert N in [8, 16, 32, 64, 128, 256]
-return value.to_bytes(N // 8, 'little')
+return value.to_bytes(N // 8, "little")
```
-### `bool`
+### `"bool"`
```python
assert value in (True, False)
-return b'\x01' if value is True else b'\x00'
+return b"\x01" if value is True else b"\x00"
```
-### Tuples, containers, lists
+### Vectors, containers, lists
-If `value` is fixed-length (i.e. does not embed a list):
+If `value` is fixed-size:
```python
-return ''.join([serialize(element) for element in value])
+return "".join([serialize(element) for element in value])
```
-If `value` is variable-length (i.e. embeds a list):
+If `value` is variable-size:
```python
-serialized_bytes = ''.join([serialize(element) for element in value])
+serialized_bytes = "".join([serialize(element) for element in value])
assert len(serialized_bytes) < 2**(8 * BYTES_PER_LENGTH_PREFIX)
-serialized_length = len(serialized_bytes).to_bytes(BYTES_PER_LENGTH_PREFIX, 'little')
+serialized_length = len(serialized_bytes).to_bytes(BYTES_PER_LENGTH_PREFIX, "little")
return serialized_length + serialized_bytes
```
@@ -99,9 +101,9 @@ We first define helper functions:
We now define Merkleization `hash_tree_root(value)` of an object `value` recursively:
-* `merkleize(pack(value))` if `value` is a basic object or a tuple of basic objects
+* `merkleize(pack(value))` if `value` is a basic object or a vector of basic objects
* `mix_in_length(merkleize(pack(value)), len(value))` if `value` is a list of basic objects
-* `merkleize([hash_tree_root(element) for element in value])` if `value` is a tuple of composite objects or a container
+* `merkleize([hash_tree_root(element) for element in value])` if `value` is a vector of composite objects or a container
* `mix_in_length(merkleize([hash_tree_root(element) for element in value]), len(value))` if `value` is a list of composite objects
## Self-signed containers
diff --git a/specs/validator/0_beacon-chain-validator.md b/specs/validator/0_beacon-chain-validator.md
index 0c95fb446..0d6033acd 100644
--- a/specs/validator/0_beacon-chain-validator.md
+++ b/specs/validator/0_beacon-chain-validator.md
@@ -40,11 +40,11 @@ __NOTICE__: This document is a work-in-progress for researchers and implementers
- [Slot](#slot-1)
- [Shard](#shard)
- [Beacon block root](#beacon-block-root)
- - [Epoch boundary root](#epoch-boundary-root)
+ - [Target root](#target-root)
- [Crosslink data root](#crosslink-data-root)
- [Latest crosslink](#latest-crosslink)
- - [Justified epoch](#justified-epoch)
- - [Justified block root](#justified-block-root)
+ - [Source epoch](#source-epoch)
+ - [Source root](#source-root)
- [Construct attestation](#construct-attestation)
- [Data](#data)
- [Aggregation bitfield](#aggregation-bitfield)
@@ -101,8 +101,7 @@ In phase 0, all incoming validator deposits originate from the Ethereum 1.0 PoW
To submit a deposit:
* Pack the validator's [initialization parameters](#initialization) into `deposit_input`, a [`DepositInput`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#depositinput) SSZ object.
-* Set `deposit_input.proof_of_possession = EMPTY_SIGNATURE`.
-* Let `proof_of_possession` be the result of `bls_sign` of the `hash_tree_root(deposit_input)` with `domain=DOMAIN_DEPOSIT`.
+* Let `proof_of_possession` be the result of `bls_sign` of the `signed_root(deposit_input)` with `domain=DOMAIN_DEPOSIT`.
* Set `deposit_input.proof_of_possession = proof_of_possession`.
* Let `amount` be the amount in Gwei to be deposited by the validator where `MIN_DEPOSIT_AMOUNT <= amount <= MAX_DEPOSIT_AMOUNT`.
* Send a transaction on the Ethereum 1.0 chain to `DEPOSIT_CONTRACT_ADDRESS` executing `deposit` along with `serialize(deposit_input)` as the singular `bytes` input along with a deposit `amount` in Gwei.
@@ -121,11 +120,12 @@ Once a validator has been processed and added to the beacon state's `validator_r
In normal operation, the validator is quickly activated at which point the validator is added to the shuffling and begins validation after an additional `ACTIVATION_EXIT_DELAY` epochs (25.6 minutes).
-The function [`is_active_validator`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#is_active_validator) can be used to check if a validator is active during a given epoch. Usage is as follows:
+The function [`is_active_validator`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#is_active_validator) can be used to check if a validator is active during a given shuffling epoch. Note that the `BeaconState` contains a field `current_shuffling_epoch` which dictates from which epoch the current active validators are taken. Usage is as follows:
```python
+shuffling_epoch = state.current_shuffling_epoch
validator = state.validator_registry[validator_index]
-is_active = is_active_validator(validator, epoch)
+is_active = is_active_validator(validator, shuffling_epoch)
```
Once a validator is activated, the validator is assigned [responsibilities](#beacon-chain-responsibilities) until exited.
@@ -138,7 +138,7 @@ A validator has two primary responsibilities to the beacon chain -- [proposing b
### Block proposal
-A validator is expected to propose a [`BeaconBlock`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#beaconblock) at the beginning of any slot during which `get_beacon_proposer_index(state, slot)` returns the validator's `validator_index`. To propose, the validator selects the `BeaconBlock`, `parent`, that in their view of the fork choice is the head of the chain during `slot`. The validator is to create, sign, and broadcast a `block` that is a child of `parent` and that executes a valid [beacon chain state transition](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#beacon-chain-state-transition-function).
+A validator is expected to propose a [`BeaconBlock`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#beaconblock) at the beginning of any slot during which `get_beacon_proposer_index(state, slot)` returns the validator's `validator_index`. To propose, the validator selects the `BeaconBlock`, `parent`, that in their view of the fork choice is the head of the chain during `slot - 1`. The validator is to create, sign, and broadcast a `block` that is a child of `parent` and that executes a valid [beacon chain state transition](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#beacon-chain-state-transition-function).
There is one proposer per slot, so if there are N active validators any individual validator will on average be assigned to propose once per N slots (eg. at 312500 validators = 10 million ETH, that's once per ~3 weeks).
@@ -152,13 +152,13 @@ _Note:_ there might be "skipped" slots between the `parent` and `block`. These s
##### Parent root
-Set `block.parent_root = hash_tree_root(parent)`.
+Set `block.previous_block_root = signed_root(parent)`.
##### State root
Set `block.state_root = hash_tree_root(state)` of the resulting `state` of the `parent -> block` state transition.
-_Note_: To calculate `state_root`, the validator should first run the state transition function on an unsigned `block` containing a stub for the `state_root`. It is useful to be able to run a state transition function that does _not_ validate signatures for this purpose.
+_Note_: To calculate `state_root`, the validator should first run the state transition function on an unsigned `block` containing a stub for the `state_root`. It is useful to be able to run a state transition function that does _not_ validate signatures or state root for this purpose.
##### Randao reveal
@@ -166,8 +166,8 @@ Set `block.randao_reveal = epoch_signature` where `epoch_signature` is defined a
```python
epoch_signature = bls_sign(
- privkey=validator.privkey, # privkey store locally, not in state
- message_hash=int_to_bytes32(slot_to_epoch(block.slot)),
+ privkey=validator.privkey, # privkey stored locally, not in state
+ message_hash=hash_tree_root(slot_to_epoch(block.slot)),
domain=get_domain(
fork=fork, # `fork` is the fork object at the slot `block.slot`
epoch=slot_to_epoch(block.slot),
@@ -182,35 +182,28 @@ epoch_signature = bls_sign(
* Let `D` be the set of `Eth1DataVote` objects `vote` in `state.eth1_data_votes` where:
* `vote.eth1_data.block_hash` is the hash of an eth1.0 block that is (i) part of the canonical chain, (ii) >= `ETH1_FOLLOW_DISTANCE` blocks behind the head, and (iii) newer than `state.latest_eth1_data.block_data`.
+ * `vote.eth1_data.deposit_count` is the deposit count of the eth1.0 deposit contract at the block defined by `vote.eth1_data.block_hash`.
* `vote.eth1_data.deposit_root` is the deposit root of the eth1.0 deposit contract at the block defined by `vote.eth1_data.block_hash`.
* If `D` is empty:
* Let `block_hash` be the block hash of the `ETH1_FOLLOW_DISTANCE`'th ancestor of the head of the canonical eth1.0 chain.
- * Let `deposit_root` be the deposit root of the eth1.0 deposit contract in the post-state of the block referenced by `block_hash`
+ * Let `deposit_root` and `deposit_count` be the deposit root and deposit count of the eth1.0 deposit contract in the post-state of the block referenced by `block_hash`
+ * Let `best_vote_data = Eth1Data(block_hash=block_hash, deposit_root=deposit_root, deposit_count=deposit_count)`.
* If `D` is nonempty:
- * Let `best_vote` be the member of `D` that has the highest `vote.vote_count`, breaking ties by favoring block hashes with higher associated block height.
- * Let `block_hash = best_vote.eth1_data.block_hash`.
- * Let `deposit_root = best_vote.eth1_data.deposit_root`.
-* Set `block.eth1_data = Eth1Data(deposit_root=deposit_root, block_hash=block_hash)`.
+ * Let `best_vote_data` be the `eth1_data` of the member of `D` that has the highest `vote.vote_count`, breaking ties by favoring block hashes with higher associated block height.
+* Set `block.eth1_data = best_vote_data`.
##### Signature
-Set `block.signature = signed_proposal_data` where `signed_proposal_data` is defined as:
+Set `block.signature = block_signature` where `block_signature` is defined as:
```python
-proposal_data = ProposalSignedData(
- slot=slot,
- shard=BEACON_CHAIN_SHARD_NUMBER,
- block_root=hash_tree_root(block), # where `block.sigature == EMPTY_SIGNATURE
-)
-proposal_root = hash_tree_root(proposal_data)
-
-signed_proposal_data = bls_sign(
+block_signature = bls_sign(
privkey=validator.privkey, # privkey store locally, not in state
- message_hash=proposal_root,
+ message_hash=signed_root(block),
domain=get_domain(
fork=fork, # `fork` is the fork object at the slot `block.slot`
epoch=slot_to_epoch(block.slot),
- domain_type=DOMAIN_PROPOSAL,
+ domain_type=DOMAIN_BEACON_BLOCK,
)
)
```
@@ -219,23 +212,25 @@ signed_proposal_data = bls_sign(
##### Proposer slashings
-Up to `MAX_PROPOSER_SLASHINGS` [`ProposerSlashing`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#proposerslashing) objects can be included in the `block`. The proposer slashings must satisfy the verification conditions found in [proposer slashings processing](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#proposer-slashings-1). The validator receives a small "whistleblower" reward for each proposer slashing found and included.
+Up to `MAX_PROPOSER_SLASHINGS` [`ProposerSlashing`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#proposerslashing) objects can be included in the `block`. The proposer slashings must satisfy the verification conditions found in [proposer slashings processing](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#proposer-slashings). The validator receives a small "whistleblower" reward for each proposer slashing found and included.
##### Attester slashings
-Up to `MAX_ATTESTER_SLASHINGS` [`AttesterSlashing`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#attesterslashing) objects can be included in the `block`. The attester slashings must satisfy the verification conditions found in [Attester slashings processing](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#attester-slashings-1). The validator receives a small "whistleblower" reward for each attester slashing found and included.
+Up to `MAX_ATTESTER_SLASHINGS` [`AttesterSlashing`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#attesterslashing) objects can be included in the `block`. The attester slashings must satisfy the verification conditions found in [Attester slashings processing](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#attester-slashings). The validator receives a small "whistleblower" reward for each attester slashing found and included.
##### Attestations
-Up to `MAX_ATTESTATIONS` aggregate attestations can be included in the `block`. The attestations added must satisfy the verification conditions found in [attestation processing](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#attestations-1). To maximize profit, the validator should attempt to create aggregate attestations that include singular attestations from the largest number of validators whose signatures from the same epoch have not previously been added on chain.
+Up to `MAX_ATTESTATIONS` aggregate attestations can be included in the `block`. The attestations added must satisfy the verification conditions found in [attestation processing](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#attestations). To maximize profit, the validator should attempt to gather aggregate attestations that include singular attestations from the largest number of validators whose signatures from the same epoch have not previously been added on chain.
##### Deposits
-Up to `MAX_DEPOSITS` [`Deposit`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#deposit) objects can be included in the `block`. These deposits are constructed from the `Deposit` logs from the [Eth1.0 deposit contract](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#ethereum-10-deposit-contract) and must be processed in sequential order. The deposits included in the `block` must satisfy the verification conditions found in [deposits processing](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#deposits-1).
+If there are any unprocessed deposits for the existing `state.latest_eth1_data` (i.e. `state.latest_eth1_data.deposit_count > state.deposit_index`), then pending deposits _must_ be added to the block. The expected number of deposits is exactly `min(MAX_DEPOSITS, latest_eth1_data.deposit_count - state.deposit_index)`. These [`deposits`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#deposit) are constructed from the `Deposit` logs from the [Eth1.0 deposit contract](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#ethereum-10-deposit-contract) and must be processed in sequential order. The deposits included in the `block` must satisfy the verification conditions found in [deposits processing](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#deposits).
+
+The `proof` for each deposit must be constructed against the deposit root contained in `state.latest_eth1_data` rather than the deposit root at the time the deposit was initially logged from the 1.0 chain. This entails storing a full deposit merkle tree locally and computing updated proofs against the `latest_eth1_data.deposit_root` as needed. See [`minimal_merkle.py`](https://github.com/ethereum/research/blob/master/spec_pythonizer/utils/merkle_minimal.py) for a sample implementation.
##### Voluntary exits
-Up to `MAX_VOLUNTARY_EXITS` [`VoluntaryExit`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#voluntaryexit) objects can be included in the `block`. The exits must satisfy the verification conditions found in [exits processing](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#exits-1).
+Up to `MAX_VOLUNTARY_EXITS` [`VoluntaryExit`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#voluntaryexit) objects can be included in the `block`. The exits must satisfy the verification conditions found in [exits processing](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#voluntary-exits).
### Attestations
@@ -247,9 +242,12 @@ A validator should create and broadcast the attestation halfway through the `slo
First the validator should construct `attestation_data`, an [`AttestationData`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#attestationdata) object based upon the state at the assigned slot.
+* Let `head_block` be the result of running the fork choice during the assigned slot.
+* Let `head_state` be the state of `head_block` processed through any empty slots up to the assigned slot.
+
##### Slot
-Set `attestation_data.slot = slot` where `slot` is the current slot of which the validator is a member of a committee.
+Set `attestation_data.slot = head_state.slot`.
##### Shard
@@ -257,15 +255,15 @@ Set `attestation_data.shard = shard` where `shard` is the shard associated with
##### Beacon block root
-Set `attestation_data.beacon_block_root = hash_tree_root(head)` where `head` is the validator's view of the `head` block of the beacon chain during `slot`.
+Set `attestation_data.beacon_block_root = signed_root(head_block)`.
-##### Epoch boundary root
+##### Target root
-Set `attestation_data.epoch_boundary_root = hash_tree_root(epoch_boundary)` where `epoch_boundary` is the block at the most recent epoch boundary in the chain defined by `head` -- i.e. the `BeaconBlock` where `block.slot == get_epoch_start_slot(slot_to_epoch(head.slot))`.
+Set `attestation_data.target_root = signed_root(epoch_boundary)` where `epoch_boundary` is the block at the most recent epoch boundary.
_Note:_ This can be looked up in the state using:
-* Let `epoch_start_slot = get_epoch_start_slot(slot_to_epoch(head.slot))`.
-* Set `epoch_boundary_root = hash_tree_root(head) if epoch_start_slot == head.slot else get_block_root(state, epoch_start_slot)`.
+* Let `epoch_start_slot = get_epoch_start_slot(get_current_epoch(head_state))`.
+* Set `epoch_boundary = head if epoch_start_slot == head_state.slot else get_block_root(state, epoch_start_slot)`.
##### Crosslink data root
@@ -275,17 +273,15 @@ _Note:_ This is a stub for phase 0.
##### Latest crosslink
-Set `attestation_data.latest_crosslink = state.latest_crosslinks[shard]` where `state` is the beacon state at `head` and `shard` is the validator's assigned shard.
+Set `attestation_data.previous_crosslink = head_state.latest_crosslinks[shard]`.
-##### Justified epoch
+##### Source epoch
-Set `attestation_data.justified_epoch = state.justified_epoch` where `state` is the beacon state at `head`.
+Set `attestation_data.source_epoch = head_state.justified_epoch`.
-##### Justified block root
+##### Source root
-Set `attestation_data.justified_block_root = hash_tree_root(justified_block)` where `justified_block` is the block at the slot `get_epoch_start_slot(state.justified_epoch)` in the chain defined by `head`.
-
-_Note:_ This can be looked up in the state using `get_block_root(state, get_epoch_start_slot(state.justified_epoch))`.
+Set `attestation_data.source_root = head_state.current_justified_root`.
#### Construct attestation
@@ -320,11 +316,11 @@ attestation_data_and_custody_bit = AttestationDataAndCustodyBit(
data=attestation.data,
custody_bit=0b0,
)
-attestation_message_to_sign = hash_tree_root(attestation_data_and_custody_bit)
+attestation_message = hash_tree_root(attestation_data_and_custody_bit)
signed_attestation_data = bls_sign(
- privkey=validator.privkey, # privkey store locally, not in state
- message_hash=attestation_message_to_sign,
+ privkey=validator.privkey, # privkey stored locally, not in state
+ message_hash=attestation_message,
domain=get_domain(
fork=fork, # `fork` is the fork object at the slot, `attestation_data.slot`
epoch=slot_to_epoch(attestation_data.slot),
@@ -335,22 +331,19 @@ signed_attestation_data = bls_sign(
## Validator assignments
-A validator can get the current and previous epoch committee assignments using the following helper via `get_committee_assignment(state, epoch, validator_index)` where `previous_epoch <= epoch <= current_epoch`.
+A validator can get the current, previous, and next epoch committee assignments using the following helper via `get_committee_assignment(state, epoch, validator_index)` where `previous_epoch <= epoch <= next_epoch`.
```python
def get_committee_assignment(
state: BeaconState,
epoch: Epoch,
- validator_index: ValidatorIndex,
- registry_change: bool=False) -> Tuple[List[ValidatorIndex], Shard, Slot, bool]:
+ validator_index: ValidatorIndex) -> Tuple[List[ValidatorIndex], Shard, Slot]:
"""
- Return the committee assignment in the ``epoch`` for ``validator_index`` and ``registry_change``.
+ Return the committee assignment in the ``epoch`` for ``validator_index``.
``assignment`` returned is a tuple of the following form:
* ``assignment[0]`` is the list of validators in the committee
* ``assignment[1]`` is the shard to which the committee is assigned
* ``assignment[2]`` is the slot at which the committee is assigned
- * ``assignment[3]`` is a bool signalling if the validator is expected to propose
- a beacon block at the assigned slot.
"""
previous_epoch = get_previous_epoch(state)
next_epoch = get_current_epoch(state) + 1
@@ -361,7 +354,6 @@ def get_committee_assignment(
crosslink_committees = get_crosslink_committees_at_slot(
state,
slot,
- registry_change=registry_change,
)
selected_committees = [
committee # Tuple[List[ValidatorIndex], Shard]
@@ -371,28 +363,33 @@ def get_committee_assignment(
if len(selected_committees) > 0:
validators = selected_committees[0][0]
shard = selected_committees[0][1]
- is_proposer = validator_index == get_beacon_proposer_index(state, slot, registry_change=registry_change)
- assignment = (validators, shard, slot, is_proposer)
+ assignment = (validators, shard, slot)
return assignment
```
+A validator can use the following function to see if they are supposed to propose during their assigned committee slot. This function can only be run during the epoch of the slot in question and can not reliably be used to predict an epoch in advance.
+
+```python
+def is_proposer_at_slot(state: BeaconState,
+ slot: Slot,
+ validator_index: ValidatorIndex) -> bool:
+ current_epoch = get_current_epoch(state)
+ assert slot_to_epoch(slot) == current_epoch
+
+ return get_beacon_proposer_index(state, slot) == validator_index
+```
+
+_Note_: If a validator is assigned to the 0th slot of an epoch, the validator must run an empty slot transition from the previous epoch into the 0th slot of the epoch to be able to check if they are a proposer at that slot.
+
+
### Lookahead
-The beacon chain shufflings are designed to provide a minimum of 1 epoch lookahead on the validator's upcoming assignments of proposing and attesting dictated by the shuffling and slot.
+The beacon chain shufflings are designed to provide a minimum of 1 epoch lookahead on the validator's upcoming committee assignments for attesting dictated by the shuffling and slot. Note that this lookahead does not apply to proposing which must checked during the epoch in question.
-There are three possibilities for the shuffling at the next epoch:
-1. The shuffling changes due to a "validator registry change".
-2. The shuffling changes due to `epochs_since_last_registry_update` being an exact power of 2 greater than 1.
-3. The shuffling remains the same (i.e. the validator is in the same shard committee).
+`get_committee_assignment` should be called at the start of each epoch to get the assignment for the next epoch (`current_epoch + 1`). A validator should plan for future assignments which involves noting at which future slot one will have to attest and also which shard one should begin syncing (in phase 1+).
-Either (2) or (3) occurs if (1) fails. The choice between (2) and (3) is deterministic based upon `epochs_since_last_registry_update`.
-
-When querying for assignments in the next epoch there are two options -- with and without a `registry_change` -- which is the optional fourth parameter of the `get_committee_assignment`.
-
-`get_committee_assignment` should be called at the start of each epoch to get the assignment for the next epoch (`current_epoch + 1`). A validator should always plan for assignments from both values of `registry_change` unless the validator can concretely eliminate one of the options. Planning for future assignments involves noting at which future slot one might have to attest and propose and also which shard one should begin syncing (in phase 1+).
-
-Specifically, a validator should call both `get_committee_assignment(state, next_epoch, validator_index, registry_change=True)` and `get_committee_assignment(state, next_epoch, validator_index, registry_change=False)` when checking for next epoch assignments.
+Specifically, a validator should call `get_committee_assignment(state, next_epoch, validator_index)` when checking for next epoch assignments.
## How to avoid slashing
@@ -402,12 +399,12 @@ _Note_: Signed data must be within a sequential `Fork` context to conflict. Mess
### Proposer slashing
-To avoid "proposer slashings", a validator must not sign two conflicting [`ProposalSignedData`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#proposalsigneddata) where conflicting is defined as having the same `slot` and `shard` but a different `block_root`. In phase 0, proposals are only made for the beacon chain (`shard == BEACON_CHAIN_SHARD_NUMBER`).
+To avoid "proposer slashings", a validator must not sign two conflicting [`BeaconBlock`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#proposalsigneddata) where conflicting is defined as two distinct blocks within the same epoch.
-_In phase 0, as long as the validator does not sign two different beacon chain proposals for the same slot, the validator is safe against proposer slashings._
+_In phase 0, as long as the validator does not sign two different beacon blocks for the same epoch, the validator is safe against proposer slashings._
Specifically, when signing an `BeaconBlock`, a validator should perform the following steps in the following order:
-1. Save a record to hard disk that an beacon block has been signed for the `slot=slot` and `shard=BEACON_CHAIN_SHARD_NUMBER`.
+1. Save a record to hard disk that an beacon block has been signed for the `epoch=slot_to_epoch(block.slot)`.
2. Generate and broadcast the block.
If the software crashes at some point within this routine, then when the validator comes back online the hard disk has the record of the _potentially_ signed/broadcast block and can effectively avoid slashing.
@@ -417,7 +414,7 @@ If the software crashes at some point within this routine, then when the validat
To avoid "attester slashings", a validator must not sign two conflicting [`AttestationData`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#attestationdata) objects where conflicting is defined as a set of two attestations that satisfy either [`is_double_vote`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#is_double_vote) or [`is_surround_vote`](https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#is_surround_vote).
Specifically, when signing an `Attestation`, a validator should perform the following steps in the following order:
-1. Save a record to hard disk that an attestation has been signed for source -- `attestation_data.justified_epoch` -- and target -- `slot_to_epoch(attestation_data.slot)`.
+1. Save a record to hard disk that an attestation has been signed for source -- `attestation_data.source_epoch` -- and target -- `slot_to_epoch(attestation_data.slot)`.
2. Generate and broadcast attestation.
If the software crashes at some point within this routine, then when the validator comes back online the hard disk has the record of the _potentially_ signed/broadcast attestation and can effectively avoid slashing.
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/phase0/__init__.py b/tests/phase0/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/phase0/block_processing/test_process_attestation.py b/tests/phase0/block_processing/test_process_attestation.py
new file mode 100644
index 000000000..ca6933ce7
--- /dev/null
+++ b/tests/phase0/block_processing/test_process_attestation.py
@@ -0,0 +1,153 @@
+from copy import deepcopy
+import pytest
+
+import build.phase0.spec as spec
+
+from build.phase0.state_transition import (
+ state_transition,
+)
+from build.phase0.spec import (
+ ZERO_HASH,
+ get_current_epoch,
+ process_attestation,
+ slot_to_epoch,
+)
+from tests.phase0.helpers import (
+ build_empty_block_for_next_slot,
+ get_valid_attestation,
+)
+
+
+# mark entire file as 'attestations'
+pytestmark = pytest.mark.attestations
+
+
+def run_attestation_processing(state, attestation, valid=True):
+ """
+ Run ``process_attestation`` returning the pre and post state.
+ If ``valid == False``, run expecting ``AssertionError``
+ """
+ post_state = deepcopy(state)
+
+ if not valid:
+ with pytest.raises(AssertionError):
+ process_attestation(post_state, attestation)
+ return state, None
+
+ process_attestation(post_state, attestation)
+
+ current_epoch = get_current_epoch(state)
+ target_epoch = slot_to_epoch(attestation.data.slot)
+ if target_epoch == current_epoch:
+ assert len(post_state.current_epoch_attestations) == len(state.current_epoch_attestations) + 1
+ else:
+ assert len(post_state.previous_epoch_attestations) == len(state.previous_epoch_attestations) + 1
+
+ return state, post_state
+
+
+def test_success(state):
+ attestation = get_valid_attestation(state)
+ state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+
+ pre_state, post_state = run_attestation_processing(state, attestation)
+
+ return pre_state, attestation, post_state
+
+
+def test_success_prevous_epoch(state):
+ attestation = get_valid_attestation(state)
+ block = build_empty_block_for_next_slot(state)
+ block.slot = state.slot + spec.SLOTS_PER_EPOCH
+ state_transition(state, block)
+
+ pre_state, post_state = run_attestation_processing(state, attestation)
+
+ return pre_state, attestation, post_state
+
+
+def test_before_inclusion_delay(state):
+ attestation = get_valid_attestation(state)
+ # do not increment slot to allow for inclusion delay
+
+ pre_state, post_state = run_attestation_processing(state, attestation, False)
+
+ return pre_state, attestation, post_state
+
+
+def test_after_epoch_slots(state):
+ attestation = get_valid_attestation(state)
+ block = build_empty_block_for_next_slot(state)
+ # increment past latest inclusion slot
+ block.slot = state.slot + spec.SLOTS_PER_EPOCH + 1
+ state_transition(state, block)
+
+ pre_state, post_state = run_attestation_processing(state, attestation, False)
+
+ return pre_state, attestation, post_state
+
+
+def test_bad_source_epoch(state):
+ attestation = get_valid_attestation(state)
+ state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+
+ attestation.data.source_epoch += 10
+
+ pre_state, post_state = run_attestation_processing(state, attestation, False)
+
+ return pre_state, attestation, post_state
+
+
+def test_bad_source_root(state):
+ attestation = get_valid_attestation(state)
+ state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+
+ attestation.data.source_root = b'\x42'*32
+
+ pre_state, post_state = run_attestation_processing(state, attestation, False)
+
+ return pre_state, attestation, post_state
+
+
+def test_non_zero_crosslink_data_root(state):
+ attestation = get_valid_attestation(state)
+ state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+
+ attestation.data.crosslink_data_root = b'\x42'*32
+
+ pre_state, post_state = run_attestation_processing(state, attestation, False)
+
+ return pre_state, attestation, post_state
+
+
+def test_bad_previous_crosslink(state):
+ attestation = get_valid_attestation(state)
+ state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+
+ state.latest_crosslinks[attestation.data.shard].epoch += 10
+
+ pre_state, post_state = run_attestation_processing(state, attestation, False)
+
+ return pre_state, attestation, post_state
+
+
+def test_non_empty_custody_bitfield(state):
+ attestation = get_valid_attestation(state)
+ state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+
+ attestation.custody_bitfield = deepcopy(attestation.aggregation_bitfield)
+
+ pre_state, post_state = run_attestation_processing(state, attestation, False)
+
+ return pre_state, attestation, post_state
+
+
+def test_empty_aggregation_bitfield(state):
+ attestation = get_valid_attestation(state)
+ state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+
+ attestation.aggregation_bitfield = b'\x00' * len(attestation.aggregation_bitfield)
+
+ pre_state, post_state = run_attestation_processing(state, attestation, False)
+
+ return pre_state, attestation, post_state
diff --git a/tests/phase0/block_processing/test_process_block_header.py b/tests/phase0/block_processing/test_process_block_header.py
new file mode 100644
index 000000000..4981b656c
--- /dev/null
+++ b/tests/phase0/block_processing/test_process_block_header.py
@@ -0,0 +1,71 @@
+from copy import deepcopy
+import pytest
+
+
+from build.phase0.spec import (
+ get_beacon_proposer_index,
+ cache_state,
+ advance_slot,
+ process_block_header,
+)
+from tests.phase0.helpers import (
+ build_empty_block_for_next_slot,
+)
+
+# mark entire file as 'header'
+pytestmark = pytest.mark.header
+
+
+def prepare_state_for_header_processing(state):
+ cache_state(state)
+ advance_slot(state)
+
+
+def run_block_header_processing(state, block, valid=True):
+ """
+ Run ``process_block_header`` returning the pre and post state.
+ If ``valid == False``, run expecting ``AssertionError``
+ """
+ prepare_state_for_header_processing(state)
+ post_state = deepcopy(state)
+
+ if not valid:
+ with pytest.raises(AssertionError):
+ process_block_header(post_state, block)
+ return state, None
+
+ process_block_header(post_state, block)
+ return state, post_state
+
+
+def test_success(state):
+ block = build_empty_block_for_next_slot(state)
+ pre_state, post_state = run_block_header_processing(state, block)
+ return state, block, post_state
+
+
+def test_invalid_slot(state):
+ block = build_empty_block_for_next_slot(state)
+ block.slot = state.slot + 2 # invalid slot
+
+ pre_state, post_state = run_block_header_processing(state, block, valid=False)
+ return pre_state, block, None
+
+
+def test_invalid_previous_block_root(state):
+ block = build_empty_block_for_next_slot(state)
+ block.previous_block_root = b'\12'*32 # invalid prev root
+
+ pre_state, post_state = run_block_header_processing(state, block, valid=False)
+ return pre_state, block, None
+
+
+def test_proposer_slashed(state):
+ # set proposer to slashed
+ proposer_index = get_beacon_proposer_index(state, state.slot + 1)
+ state.validator_registry[proposer_index].slashed = True
+
+ block = build_empty_block_for_next_slot(state)
+
+ pre_state, post_state = run_block_header_processing(state, block, valid=False)
+ return pre_state, block, None
diff --git a/tests/phase0/block_processing/test_process_deposit.py b/tests/phase0/block_processing/test_process_deposit.py
new file mode 100644
index 000000000..0726dddef
--- /dev/null
+++ b/tests/phase0/block_processing/test_process_deposit.py
@@ -0,0 +1,141 @@
+from copy import deepcopy
+import pytest
+
+import build.phase0.spec as spec
+
+from build.phase0.spec import (
+ get_balance,
+ ZERO_HASH,
+ process_deposit,
+)
+from tests.phase0.helpers import (
+ build_deposit,
+ privkeys,
+ pubkeys,
+)
+
+
+# mark entire file as 'voluntary_exits'
+pytestmark = pytest.mark.voluntary_exits
+
+
+def test_success(state):
+ pre_state = deepcopy(state)
+ # fill previous deposits with zero-hash
+ deposit_data_leaves = [ZERO_HASH] * len(pre_state.validator_registry)
+
+ index = len(deposit_data_leaves)
+ pubkey = pubkeys[index]
+ privkey = privkeys[index]
+ deposit, root, deposit_data_leaves = build_deposit(
+ pre_state,
+ deposit_data_leaves,
+ pubkey,
+ privkey,
+ spec.MAX_DEPOSIT_AMOUNT,
+ )
+
+ pre_state.latest_eth1_data.deposit_root = root
+ pre_state.latest_eth1_data.deposit_count = len(deposit_data_leaves)
+
+ post_state = deepcopy(pre_state)
+
+ process_deposit(post_state, deposit)
+
+ assert len(post_state.validator_registry) == len(state.validator_registry) + 1
+ assert len(post_state.balances) == len(state.balances) + 1
+ assert post_state.validator_registry[index].pubkey == pubkeys[index]
+ assert get_balance(post_state, index) == spec.MAX_DEPOSIT_AMOUNT
+ assert post_state.deposit_index == post_state.latest_eth1_data.deposit_count
+
+ return pre_state, deposit, post_state
+
+
+def test_success_top_up(state):
+ pre_state = deepcopy(state)
+ deposit_data_leaves = [ZERO_HASH] * len(pre_state.validator_registry)
+
+ validator_index = 0
+ amount = spec.MAX_DEPOSIT_AMOUNT // 4
+ pubkey = pubkeys[validator_index]
+ privkey = privkeys[validator_index]
+ deposit, root, deposit_data_leaves = build_deposit(
+ pre_state,
+ deposit_data_leaves,
+ pubkey,
+ privkey,
+ amount,
+ )
+
+ pre_state.latest_eth1_data.deposit_root = root
+ pre_state.latest_eth1_data.deposit_count = len(deposit_data_leaves)
+ pre_balance = get_balance(pre_state, validator_index)
+
+ post_state = deepcopy(pre_state)
+
+ process_deposit(post_state, deposit)
+
+ assert len(post_state.validator_registry) == len(state.validator_registry)
+ assert len(post_state.balances) == len(state.balances)
+ assert post_state.deposit_index == post_state.latest_eth1_data.deposit_count
+ assert get_balance(post_state, validator_index) == pre_balance + amount
+
+ return pre_state, deposit, post_state
+
+
+def test_wrong_index(state):
+ pre_state = deepcopy(state)
+ deposit_data_leaves = [ZERO_HASH] * len(pre_state.validator_registry)
+
+ index = len(deposit_data_leaves)
+ pubkey = pubkeys[index]
+ privkey = privkeys[index]
+ deposit, root, deposit_data_leaves = build_deposit(
+ pre_state,
+ deposit_data_leaves,
+ pubkey,
+ privkey,
+ spec.MAX_DEPOSIT_AMOUNT,
+ )
+
+ # mess up deposit_index
+ deposit.index = pre_state.deposit_index + 1
+
+ pre_state.latest_eth1_data.deposit_root = root
+ pre_state.latest_eth1_data.deposit_count = len(deposit_data_leaves)
+
+ post_state = deepcopy(pre_state)
+
+ with pytest.raises(AssertionError):
+ process_deposit(post_state, deposit)
+
+ return pre_state, deposit, None
+
+
+def test_bad_merkle_proof(state):
+ pre_state = deepcopy(state)
+ deposit_data_leaves = [ZERO_HASH] * len(pre_state.validator_registry)
+
+ index = len(deposit_data_leaves)
+ pubkey = pubkeys[index]
+ privkey = privkeys[index]
+ deposit, root, deposit_data_leaves = build_deposit(
+ pre_state,
+ deposit_data_leaves,
+ pubkey,
+ privkey,
+ spec.MAX_DEPOSIT_AMOUNT,
+ )
+
+ # mess up merkle branch
+ deposit.proof[-1] = spec.ZERO_HASH
+
+ pre_state.latest_eth1_data.deposit_root = root
+ pre_state.latest_eth1_data.deposit_count = len(deposit_data_leaves)
+
+ post_state = deepcopy(pre_state)
+
+ with pytest.raises(AssertionError):
+ process_deposit(post_state, deposit)
+
+ return pre_state, deposit, None
diff --git a/tests/phase0/block_processing/test_process_proposer_slashing.py b/tests/phase0/block_processing/test_process_proposer_slashing.py
new file mode 100644
index 000000000..467d2164b
--- /dev/null
+++ b/tests/phase0/block_processing/test_process_proposer_slashing.py
@@ -0,0 +1,97 @@
+from copy import deepcopy
+import pytest
+
+import build.phase0.spec as spec
+from build.phase0.spec import (
+ get_balance,
+ get_current_epoch,
+ process_proposer_slashing,
+)
+from tests.phase0.helpers import (
+ get_valid_proposer_slashing,
+)
+
+# mark entire file as 'header'
+pytestmark = pytest.mark.proposer_slashings
+
+
+def run_proposer_slashing_processing(state, proposer_slashing, valid=True):
+ """
+ Run ``process_proposer_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_proposer_slashing(post_state, proposer_slashing)
+ return state, None
+
+ process_proposer_slashing(post_state, proposer_slashing)
+
+ slashed_validator = post_state.validator_registry[proposer_slashing.proposer_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, proposer_slashing.proposer_index) <
+ get_balance(state, proposer_slashing.proposer_index)
+ )
+
+ return state, post_state
+
+
+def test_success(state):
+ proposer_slashing = get_valid_proposer_slashing(state)
+
+ pre_state, post_state = run_proposer_slashing_processing(state, proposer_slashing)
+
+ return pre_state, proposer_slashing, post_state
+
+
+def test_epochs_are_different(state):
+ proposer_slashing = get_valid_proposer_slashing(state)
+
+ # set slots to be in different epochs
+ proposer_slashing.header_2.slot += spec.SLOTS_PER_EPOCH
+
+ pre_state, post_state = run_proposer_slashing_processing(state, proposer_slashing, False)
+
+ return pre_state, proposer_slashing, post_state
+
+
+def test_headers_are_same(state):
+ proposer_slashing = get_valid_proposer_slashing(state)
+
+ # set headers to be the same
+ proposer_slashing.header_2 = proposer_slashing.header_1
+
+ pre_state, post_state = run_proposer_slashing_processing(state, proposer_slashing, False)
+
+ return pre_state, proposer_slashing, post_state
+
+
+def test_proposer_is_slashed(state):
+ proposer_slashing = get_valid_proposer_slashing(state)
+
+ # set proposer to slashed
+ state.validator_registry[proposer_slashing.proposer_index].slashed = True
+
+ pre_state, post_state = run_proposer_slashing_processing(state, proposer_slashing, False)
+
+ return pre_state, proposer_slashing, post_state
+
+
+def test_proposer_is_withdrawn(state):
+ proposer_slashing = get_valid_proposer_slashing(state)
+
+ # set proposer withdrawable_epoch in past
+ current_epoch = get_current_epoch(state)
+ proposer_index = proposer_slashing.proposer_index
+ state.validator_registry[proposer_index].withdrawable_epoch = current_epoch - 1
+
+ pre_state, post_state = run_proposer_slashing_processing(state, proposer_slashing, False)
+
+ return pre_state, proposer_slashing, post_state
diff --git a/tests/phase0/block_processing/test_voluntary_exit.py b/tests/phase0/block_processing/test_voluntary_exit.py
new file mode 100644
index 000000000..6adc81464
--- /dev/null
+++ b/tests/phase0/block_processing/test_voluntary_exit.py
@@ -0,0 +1,175 @@
+from copy import deepcopy
+import pytest
+
+import build.phase0.spec as spec
+
+from build.phase0.spec import (
+ get_active_validator_indices,
+ get_current_epoch,
+ process_voluntary_exit,
+)
+from tests.phase0.helpers import (
+ build_voluntary_exit,
+ pubkey_to_privkey,
+)
+
+
+# mark entire file as 'voluntary_exits'
+pytestmark = pytest.mark.voluntary_exits
+
+
+def test_success(state):
+ pre_state = deepcopy(state)
+ #
+ # setup pre_state
+ #
+ # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit
+ pre_state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH
+
+ #
+ # build voluntary exit
+ #
+ current_epoch = get_current_epoch(pre_state)
+ validator_index = get_active_validator_indices(pre_state.validator_registry, current_epoch)[0]
+ privkey = pubkey_to_privkey[pre_state.validator_registry[validator_index].pubkey]
+
+ voluntary_exit = build_voluntary_exit(
+ pre_state,
+ current_epoch,
+ validator_index,
+ privkey,
+ )
+
+ post_state = deepcopy(pre_state)
+
+ #
+ # test valid exit
+ #
+ process_voluntary_exit(post_state, voluntary_exit)
+
+ assert not pre_state.validator_registry[validator_index].initiated_exit
+ assert post_state.validator_registry[validator_index].initiated_exit
+
+ return pre_state, voluntary_exit, post_state
+
+
+def test_validator_not_active(state):
+ pre_state = deepcopy(state)
+ current_epoch = get_current_epoch(pre_state)
+ validator_index = get_active_validator_indices(pre_state.validator_registry, current_epoch)[0]
+ privkey = pubkey_to_privkey[pre_state.validator_registry[validator_index].pubkey]
+
+ #
+ # setup pre_state
+ #
+ pre_state.validator_registry[validator_index].activation_epoch = spec.FAR_FUTURE_EPOCH
+
+ #
+ # build and test voluntary exit
+ #
+ voluntary_exit = build_voluntary_exit(
+ pre_state,
+ current_epoch,
+ validator_index,
+ privkey,
+ )
+
+ with pytest.raises(AssertionError):
+ process_voluntary_exit(pre_state, voluntary_exit)
+
+ return pre_state, voluntary_exit, None
+
+
+def test_validator_already_exited(state):
+ pre_state = deepcopy(state)
+ #
+ # setup pre_state
+ #
+ # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow validator able to exit
+ pre_state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH
+
+ current_epoch = get_current_epoch(pre_state)
+ validator_index = get_active_validator_indices(pre_state.validator_registry, current_epoch)[0]
+ privkey = pubkey_to_privkey[pre_state.validator_registry[validator_index].pubkey]
+
+ # but validator already has exited
+ pre_state.validator_registry[validator_index].exit_epoch = current_epoch + 2
+
+ #
+ # build voluntary exit
+ #
+ voluntary_exit = build_voluntary_exit(
+ pre_state,
+ current_epoch,
+ validator_index,
+ privkey,
+ )
+
+ with pytest.raises(AssertionError):
+ process_voluntary_exit(pre_state, voluntary_exit)
+
+ return pre_state, voluntary_exit, None
+
+
+def test_validator_already_initiated_exit(state):
+ pre_state = deepcopy(state)
+ #
+ # setup pre_state
+ #
+ # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow validator able to exit
+ pre_state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH
+
+ current_epoch = get_current_epoch(pre_state)
+ validator_index = get_active_validator_indices(pre_state.validator_registry, current_epoch)[0]
+ privkey = pubkey_to_privkey[pre_state.validator_registry[validator_index].pubkey]
+
+ # but validator already has initiated exit
+ pre_state.validator_registry[validator_index].initiated_exit = True
+
+ #
+ # build voluntary exit
+ #
+ voluntary_exit = build_voluntary_exit(
+ pre_state,
+ current_epoch,
+ validator_index,
+ privkey,
+ )
+
+ with pytest.raises(AssertionError):
+ process_voluntary_exit(pre_state, voluntary_exit)
+
+ return pre_state, voluntary_exit, None
+
+
+def test_validator_not_active_long_enough(state):
+ pre_state = deepcopy(state)
+ #
+ # setup pre_state
+ #
+ current_epoch = get_current_epoch(pre_state)
+ validator_index = get_active_validator_indices(pre_state.validator_registry, current_epoch)[0]
+ privkey = pubkey_to_privkey[pre_state.validator_registry[validator_index].pubkey]
+
+ # but validator already has initiated exit
+ pre_state.validator_registry[validator_index].initiated_exit = True
+
+ #
+ # build voluntary exit
+ #
+ voluntary_exit = build_voluntary_exit(
+ pre_state,
+ current_epoch,
+ validator_index,
+ privkey,
+ )
+
+ assert (
+ current_epoch - pre_state.validator_registry[validator_index].activation_epoch <
+ spec.PERSISTENT_COMMITTEE_PERIOD
+ )
+
+ with pytest.raises(AssertionError):
+ process_voluntary_exit(pre_state, voluntary_exit)
+
+ return pre_state, voluntary_exit, None
diff --git a/tests/phase0/conftest.py b/tests/phase0/conftest.py
new file mode 100644
index 000000000..36a087941
--- /dev/null
+++ b/tests/phase0/conftest.py
@@ -0,0 +1,70 @@
+import pytest
+
+from build.phase0 import spec
+
+from tests.phase0.helpers import (
+ create_genesis_state,
+)
+
+
+DEFAULT_CONFIG = {} # no change
+
+MINIMAL_CONFIG = {
+ "SHARD_COUNT": 8,
+ "MIN_ATTESTATION_INCLUSION_DELAY": 2,
+ "TARGET_COMMITTEE_SIZE": 4,
+ "SLOTS_PER_EPOCH": 8,
+ "GENESIS_EPOCH": spec.GENESIS_SLOT // 8,
+ "SLOTS_PER_HISTORICAL_ROOT": 64,
+ "LATEST_RANDAO_MIXES_LENGTH": 64,
+ "LATEST_ACTIVE_INDEX_ROOTS_LENGTH": 64,
+ "LATEST_SLASHED_EXIT_LENGTH": 64,
+}
+
+
+def overwrite_spec_config(config):
+ for field in config:
+ setattr(spec, field, config[field])
+ if field == "LATEST_RANDAO_MIXES_LENGTH":
+ spec.BeaconState.fields['latest_randao_mixes'][1] = config[field]
+ elif field == "SHARD_COUNT":
+ spec.BeaconState.fields['latest_crosslinks'][1] = config[field]
+ elif field == "SLOTS_PER_HISTORICAL_ROOT":
+ spec.BeaconState.fields['latest_block_roots'][1] = config[field]
+ spec.BeaconState.fields['latest_state_roots'][1] = config[field]
+ spec.HistoricalBatch.fields['block_roots'][1] = config[field]
+ spec.HistoricalBatch.fields['state_roots'][1] = config[field]
+ elif field == "LATEST_ACTIVE_INDEX_ROOTS_LENGTH":
+ spec.BeaconState.fields['latest_active_index_roots'][1] = config[field]
+ elif field == "LATEST_SLASHED_EXIT_LENGTH":
+ spec.BeaconState.fields['latest_slashed_balances'][1] = config[field]
+
+
+@pytest.fixture(
+ params=[
+ pytest.param(MINIMAL_CONFIG, marks=pytest.mark.minimal_config),
+ DEFAULT_CONFIG,
+ ]
+)
+def config(request):
+ return request.param
+
+
+@pytest.fixture(autouse=True)
+def overwrite_config(config):
+ overwrite_spec_config(config)
+
+
+@pytest.fixture
+def num_validators():
+ return 100
+
+
+@pytest.fixture
+def deposit_data_leaves():
+ return list()
+
+
+@pytest.fixture
+def state(num_validators, deposit_data_leaves):
+ return create_genesis_state(num_validators, deposit_data_leaves)
diff --git a/tests/phase0/helpers.py b/tests/phase0/helpers.py
new file mode 100644
index 000000000..e5e335d80
--- /dev/null
+++ b/tests/phase0/helpers.py
@@ -0,0 +1,301 @@
+from copy import deepcopy
+
+from py_ecc import bls
+
+import build.phase0.spec as spec
+from build.phase0.utils.minimal_ssz import signed_root
+from build.phase0.spec import (
+ # constants
+ EMPTY_SIGNATURE,
+ ZERO_HASH,
+ # SSZ
+ Attestation,
+ AttestationData,
+ AttestationDataAndCustodyBit,
+ BeaconBlockHeader,
+ Deposit,
+ DepositData,
+ Eth1Data,
+ ProposerSlashing,
+ VoluntaryExit,
+ # functions
+ get_active_validator_indices,
+ get_attestation_participants,
+ get_block_root,
+ get_crosslink_committee_for_attestation,
+ get_crosslink_committees_at_slot,
+ get_current_epoch,
+ get_domain,
+ get_empty_block,
+ get_epoch_start_slot,
+ get_genesis_beacon_state,
+ slot_to_epoch,
+ verify_merkle_branch,
+ hash,
+)
+from build.phase0.utils.merkle_minimal import (
+ calc_merkle_tree_from_leaves,
+ get_merkle_proof,
+ get_merkle_root,
+)
+
+
+privkeys = [i + 1 for i in range(1000)]
+pubkeys = [bls.privtopub(privkey) for privkey in privkeys]
+pubkey_to_privkey = {pubkey: privkey for privkey, pubkey in zip(privkeys, pubkeys)}
+
+
+def create_mock_genesis_validator_deposits(num_validators, deposit_data_leaves=None):
+ if not deposit_data_leaves:
+ deposit_data_leaves = []
+ proof_of_possession = b'\x33' * 96
+
+ deposit_data_list = []
+ for i in range(num_validators):
+ pubkey = pubkeys[i]
+ deposit_data = DepositData(
+ pubkey=pubkey,
+ # insecurely use pubkey as withdrawal key as well
+ withdrawal_credentials=spec.BLS_WITHDRAWAL_PREFIX_BYTE + hash(pubkey)[1:],
+ amount=spec.MAX_DEPOSIT_AMOUNT,
+ proof_of_possession=proof_of_possession,
+ )
+ item = hash(deposit_data.serialize())
+ deposit_data_leaves.append(item)
+ tree = calc_merkle_tree_from_leaves(tuple(deposit_data_leaves))
+ root = get_merkle_root((tuple(deposit_data_leaves)))
+ proof = list(get_merkle_proof(tree, item_index=i))
+ assert verify_merkle_branch(item, proof, spec.DEPOSIT_CONTRACT_TREE_DEPTH, i, root)
+ deposit_data_list.append(deposit_data)
+
+ genesis_validator_deposits = []
+ for i in range(num_validators):
+ genesis_validator_deposits.append(Deposit(
+ proof=list(get_merkle_proof(tree, item_index=i)),
+ index=i,
+ data=deposit_data_list[i]
+ ))
+ return genesis_validator_deposits, root
+
+
+def create_genesis_state(num_validators, deposit_data_leaves=None):
+ initial_deposits, deposit_root = create_mock_genesis_validator_deposits(
+ num_validators,
+ deposit_data_leaves,
+ )
+ return get_genesis_beacon_state(
+ initial_deposits,
+ genesis_time=0,
+ genesis_eth1_data=Eth1Data(
+ deposit_root=deposit_root,
+ deposit_count=len(initial_deposits),
+ block_hash=spec.ZERO_HASH,
+ ),
+ )
+
+
+def force_registry_change_at_next_epoch(state):
+ # artificially trigger registry update at next epoch transition
+ state.finalized_epoch = get_current_epoch(state) - 1
+ for crosslink in state.latest_crosslinks:
+ crosslink.epoch = state.finalized_epoch
+ state.validator_registry_update_epoch = state.finalized_epoch - 1
+
+
+def build_empty_block_for_next_slot(state):
+ empty_block = get_empty_block()
+ empty_block.slot = state.slot + 1
+ previous_block_header = deepcopy(state.latest_block_header)
+ if previous_block_header.state_root == spec.ZERO_HASH:
+ previous_block_header.state_root = state.hash_tree_root()
+ empty_block.previous_block_root = signed_root(previous_block_header)
+ return empty_block
+
+
+def build_deposit_data(state, pubkey, privkey, amount):
+ deposit_data = DepositData(
+ pubkey=pubkey,
+ # insecurely use pubkey as withdrawal key as well
+ withdrawal_credentials=spec.BLS_WITHDRAWAL_PREFIX_BYTE + hash(pubkey)[1:],
+ amount=amount,
+ proof_of_possession=EMPTY_SIGNATURE,
+ )
+ proof_of_possession = bls.sign(
+ message_hash=signed_root(deposit_data),
+ privkey=privkey,
+ domain=get_domain(
+ state.fork,
+ get_current_epoch(state),
+ spec.DOMAIN_DEPOSIT,
+ )
+ )
+ deposit_data.proof_of_possession = proof_of_possession
+ return deposit_data
+
+
+def build_attestation_data(state, slot, shard):
+ assert state.slot >= slot
+
+ block_root = build_empty_block_for_next_slot(state).previous_block_root
+
+ epoch_start_slot = get_epoch_start_slot(get_current_epoch(state))
+ if epoch_start_slot == slot:
+ epoch_boundary_root = block_root
+ else:
+ get_block_root(state, epoch_start_slot)
+
+ if slot < epoch_start_slot:
+ justified_block_root = state.previous_justified_root
+ else:
+ justified_block_root = state.current_justified_root
+
+ return AttestationData(
+ slot=slot,
+ shard=shard,
+ beacon_block_root=block_root,
+ source_epoch=state.current_justified_epoch,
+ source_root=justified_block_root,
+ target_root=epoch_boundary_root,
+ crosslink_data_root=spec.ZERO_HASH,
+ previous_crosslink=deepcopy(state.latest_crosslinks[shard]),
+ )
+
+
+def build_voluntary_exit(state, epoch, validator_index, privkey):
+ voluntary_exit = VoluntaryExit(
+ epoch=epoch,
+ validator_index=validator_index,
+ signature=EMPTY_SIGNATURE,
+ )
+ voluntary_exit.signature = bls.sign(
+ message_hash=signed_root(voluntary_exit),
+ privkey=privkey,
+ domain=get_domain(
+ fork=state.fork,
+ epoch=epoch,
+ domain_type=spec.DOMAIN_VOLUNTARY_EXIT,
+ )
+ )
+
+ return voluntary_exit
+
+
+def build_deposit(state,
+ deposit_data_leaves,
+ pubkey,
+ privkey,
+ amount):
+ deposit_data = build_deposit_data(state, pubkey, privkey, amount)
+
+ item = hash(deposit_data.serialize())
+ index = len(deposit_data_leaves)
+ deposit_data_leaves.append(item)
+ tree = calc_merkle_tree_from_leaves(tuple(deposit_data_leaves))
+ root = get_merkle_root((tuple(deposit_data_leaves)))
+ proof = list(get_merkle_proof(tree, item_index=index))
+ assert verify_merkle_branch(item, proof, spec.DEPOSIT_CONTRACT_TREE_DEPTH, index, root)
+
+ deposit = Deposit(
+ proof=list(proof),
+ index=index,
+ data=deposit_data,
+ )
+
+ return deposit, root, deposit_data_leaves
+
+
+def get_valid_proposer_slashing(state):
+ current_epoch = get_current_epoch(state)
+ validator_index = get_active_validator_indices(state.validator_registry, current_epoch)[-1]
+ privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey]
+ slot = state.slot
+
+ header_1 = BeaconBlockHeader(
+ slot=slot,
+ previous_block_root=ZERO_HASH,
+ state_root=ZERO_HASH,
+ block_body_root=ZERO_HASH,
+ signature=EMPTY_SIGNATURE,
+ )
+ header_2 = deepcopy(header_1)
+ header_2.previous_block_root = b'\x02' * 32
+ header_2.slot = slot + 1
+
+ domain = get_domain(
+ fork=state.fork,
+ epoch=get_current_epoch(state),
+ domain_type=spec.DOMAIN_BEACON_BLOCK,
+ )
+ header_1.signature = bls.sign(
+ message_hash=signed_root(header_1),
+ privkey=privkey,
+ domain=domain,
+ )
+ header_2.signature = bls.sign(
+ message_hash=signed_root(header_2),
+ privkey=privkey,
+ domain=domain,
+ )
+
+ return ProposerSlashing(
+ proposer_index=validator_index,
+ header_1=header_1,
+ header_2=header_2,
+ )
+
+
+def get_valid_attestation(state, slot=None):
+ if slot is None:
+ slot = state.slot
+ shard = state.latest_start_shard
+ attestation_data = build_attestation_data(state, slot, shard)
+
+ crosslink_committee = get_crosslink_committee_for_attestation(state, attestation_data)
+
+ committee_size = len(crosslink_committee)
+ bitfield_length = (committee_size + 7) // 8
+ aggregation_bitfield = b'\xC0' + b'\x00' * (bitfield_length - 1)
+ custody_bitfield = b'\x00' * bitfield_length
+ attestation = Attestation(
+ aggregation_bitfield=aggregation_bitfield,
+ data=attestation_data,
+ custody_bitfield=custody_bitfield,
+ aggregate_signature=EMPTY_SIGNATURE,
+ )
+ participants = get_attestation_participants(
+ state,
+ attestation.data,
+ attestation.aggregation_bitfield,
+ )
+ assert len(participants) == 2
+
+ signatures = []
+ for validator_index in participants:
+ privkey = privkeys[validator_index]
+ signatures.append(
+ get_attestation_signature(
+ state,
+ attestation.data,
+ privkey
+ )
+ )
+
+ attestation.aggregation_signature = bls.aggregate_signatures(signatures)
+ return attestation
+
+
+def get_attestation_signature(state, attestation_data, privkey, custody_bit=0b0):
+ message_hash = AttestationDataAndCustodyBit(
+ data=attestation_data,
+ custody_bit=custody_bit,
+ ).hash_tree_root()
+
+ return bls.sign(
+ message_hash=message_hash,
+ privkey=privkey,
+ domain=get_domain(
+ fork=state.fork,
+ epoch=slot_to_epoch(attestation_data.slot),
+ domain_type=spec.DOMAIN_ATTESTATION,
+ )
+ )
diff --git a/tests/phase0/test_sanity.py b/tests/phase0/test_sanity.py
new file mode 100644
index 000000000..3b4497ca5
--- /dev/null
+++ b/tests/phase0/test_sanity.py
@@ -0,0 +1,425 @@
+from copy import deepcopy
+
+import pytest
+
+from py_ecc import bls
+import build.phase0.spec as spec
+
+from build.phase0.utils.minimal_ssz import signed_root
+from build.phase0.spec import (
+ # constants
+ EMPTY_SIGNATURE,
+ ZERO_HASH,
+ # SSZ
+ Deposit,
+ Transfer,
+ VoluntaryExit,
+ # functions
+ get_active_validator_indices,
+ get_balance,
+ get_block_root,
+ get_current_epoch,
+ get_domain,
+ get_state_root,
+ advance_slot,
+ cache_state,
+ set_balance,
+ verify_merkle_branch,
+ hash,
+)
+from build.phase0.state_transition import (
+ state_transition,
+)
+from build.phase0.utils.merkle_minimal import (
+ calc_merkle_tree_from_leaves,
+ get_merkle_proof,
+ get_merkle_root,
+)
+from tests.phase0.helpers import (
+ build_deposit_data,
+ build_empty_block_for_next_slot,
+ force_registry_change_at_next_epoch,
+ get_valid_attestation,
+ get_valid_proposer_slashing,
+ privkeys,
+ pubkeys,
+)
+
+
+# mark entire file as 'sanity'
+pytestmark = pytest.mark.sanity
+
+
+def test_slot_transition(state):
+ test_state = deepcopy(state)
+ cache_state(test_state)
+ advance_slot(test_state)
+ assert test_state.slot == state.slot + 1
+ assert get_state_root(test_state, state.slot) == state.hash_tree_root()
+ return test_state
+
+
+def test_empty_block_transition(state):
+ test_state = deepcopy(state)
+
+ block = build_empty_block_for_next_slot(test_state)
+ state_transition(test_state, block)
+
+ assert len(test_state.eth1_data_votes) == len(state.eth1_data_votes) + 1
+ assert get_block_root(test_state, state.slot) == block.previous_block_root
+
+ return state, [block], test_state
+
+
+def test_skipped_slots(state):
+ test_state = deepcopy(state)
+ block = build_empty_block_for_next_slot(test_state)
+ block.slot += 3
+
+ state_transition(test_state, block)
+
+ assert test_state.slot == block.slot
+ for slot in range(state.slot, test_state.slot):
+ assert get_block_root(test_state, slot) == block.previous_block_root
+
+ return state, [block], test_state
+
+
+def test_empty_epoch_transition(state):
+ test_state = deepcopy(state)
+ block = build_empty_block_for_next_slot(test_state)
+ block.slot += spec.SLOTS_PER_EPOCH
+
+ state_transition(test_state, block)
+
+ assert test_state.slot == block.slot
+ for slot in range(state.slot, test_state.slot):
+ assert get_block_root(test_state, slot) == block.previous_block_root
+
+ return state, [block], test_state
+
+
+def test_empty_epoch_transition_not_finalizing(state):
+ test_state = deepcopy(state)
+ block = build_empty_block_for_next_slot(test_state)
+ block.slot += spec.SLOTS_PER_EPOCH * 5
+
+ state_transition(test_state, block)
+
+ assert test_state.slot == block.slot
+ assert test_state.finalized_epoch < get_current_epoch(test_state) - 4
+ for index in range(len(test_state.validator_registry)):
+ assert get_balance(test_state, index) < get_balance(state, index)
+
+ return state, [block], test_state
+
+
+def test_proposer_slashing(state):
+ test_state = deepcopy(state)
+ proposer_slashing = get_valid_proposer_slashing(state)
+ validator_index = proposer_slashing.proposer_index
+
+ #
+ # Add to state via block transition
+ #
+ block = build_empty_block_for_next_slot(test_state)
+ block.body.proposer_slashings.append(proposer_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)
+
+ 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)
+
+ index = len(test_deposit_data_leaves)
+ pubkey = pubkeys[index]
+ privkey = privkeys[index]
+ deposit_data = build_deposit_data(pre_state, pubkey, privkey, spec.MAX_DEPOSIT_AMOUNT)
+
+ item = hash(deposit_data.serialize())
+ test_deposit_data_leaves.append(item)
+ tree = calc_merkle_tree_from_leaves(tuple(test_deposit_data_leaves))
+ root = get_merkle_root((tuple(test_deposit_data_leaves)))
+ proof = list(get_merkle_proof(tree, item_index=index))
+ assert verify_merkle_branch(item, proof, spec.DEPOSIT_CONTRACT_TREE_DEPTH, index, root)
+
+ deposit = Deposit(
+ proof=list(proof),
+ index=index,
+ data=deposit_data,
+ )
+
+ pre_state.latest_eth1_data.deposit_root = root
+ pre_state.latest_eth1_data.deposit_count = len(test_deposit_data_leaves)
+ post_state = deepcopy(pre_state)
+ block = build_empty_block_for_next_slot(post_state)
+ block.body.deposits.append(deposit)
+
+ state_transition(post_state, block)
+ assert len(post_state.validator_registry) == len(state.validator_registry) + 1
+ assert len(post_state.balances) == len(state.balances) + 1
+ assert get_balance(post_state, index) == spec.MAX_DEPOSIT_AMOUNT
+ assert post_state.validator_registry[index].pubkey == pubkeys[index]
+
+ return pre_state, [block], post_state
+
+
+def test_deposit_top_up(state):
+ pre_state = deepcopy(state)
+ test_deposit_data_leaves = [ZERO_HASH] * len(pre_state.validator_registry)
+
+ validator_index = 0
+ amount = spec.MAX_DEPOSIT_AMOUNT // 4
+ pubkey = pubkeys[validator_index]
+ privkey = privkeys[validator_index]
+ deposit_data = build_deposit_data(pre_state, pubkey, privkey, amount)
+
+ merkle_index = len(test_deposit_data_leaves)
+ item = hash(deposit_data.serialize())
+ test_deposit_data_leaves.append(item)
+ tree = calc_merkle_tree_from_leaves(tuple(test_deposit_data_leaves))
+ root = get_merkle_root((tuple(test_deposit_data_leaves)))
+ proof = list(get_merkle_proof(tree, item_index=merkle_index))
+ assert verify_merkle_branch(item, proof, spec.DEPOSIT_CONTRACT_TREE_DEPTH, merkle_index, root)
+
+ deposit = Deposit(
+ proof=list(proof),
+ index=merkle_index,
+ data=deposit_data,
+ )
+
+ pre_state.latest_eth1_data.deposit_root = root
+ pre_state.latest_eth1_data.deposit_count = len(test_deposit_data_leaves)
+ block = build_empty_block_for_next_slot(pre_state)
+ block.body.deposits.append(deposit)
+
+ pre_balance = get_balance(pre_state, validator_index)
+ post_state = deepcopy(pre_state)
+ state_transition(post_state, block)
+ assert len(post_state.validator_registry) == len(pre_state.validator_registry)
+ assert len(post_state.balances) == len(pre_state.balances)
+ assert get_balance(post_state, validator_index) == pre_balance + amount
+
+ return pre_state, [block], post_state
+
+
+def test_attestation(state):
+ test_state = deepcopy(state)
+ attestation = get_valid_attestation(state)
+
+ #
+ # Add to state via block transition
+ #
+ attestation_block = build_empty_block_for_next_slot(test_state)
+ attestation_block.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+ attestation_block.body.attestations.append(attestation)
+ state_transition(test_state, attestation_block)
+
+ assert len(test_state.current_epoch_attestations) == len(state.current_epoch_attestations) + 1
+
+ #
+ # Epoch transition should move to previous_epoch_attestations
+ #
+ pre_current_epoch_attestations = deepcopy(test_state.current_epoch_attestations)
+
+ epoch_block = build_empty_block_for_next_slot(test_state)
+ epoch_block.slot += spec.SLOTS_PER_EPOCH
+ state_transition(test_state, epoch_block)
+
+ assert len(test_state.current_epoch_attestations) == 0
+ assert test_state.previous_epoch_attestations == pre_current_epoch_attestations
+
+ return state, [attestation_block, epoch_block], test_state
+
+
+def test_voluntary_exit(state):
+ pre_state = deepcopy(state)
+ validator_index = get_active_validator_indices(
+ pre_state.validator_registry,
+ get_current_epoch(pre_state)
+ )[-1]
+
+ # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit
+ pre_state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH
+ # artificially trigger registry update at next epoch transition
+ force_registry_change_at_next_epoch(pre_state)
+
+ post_state = deepcopy(pre_state)
+
+ voluntary_exit = VoluntaryExit(
+ epoch=get_current_epoch(pre_state),
+ validator_index=validator_index,
+ signature=EMPTY_SIGNATURE,
+ )
+ voluntary_exit.signature = bls.sign(
+ message_hash=signed_root(voluntary_exit),
+ privkey=privkeys[validator_index],
+ domain=get_domain(
+ fork=pre_state.fork,
+ epoch=get_current_epoch(pre_state),
+ domain_type=spec.DOMAIN_VOLUNTARY_EXIT,
+ )
+ )
+
+ #
+ # Add to state via block transition
+ #
+ initiate_exit_block = build_empty_block_for_next_slot(post_state)
+ initiate_exit_block.body.voluntary_exits.append(voluntary_exit)
+ state_transition(post_state, initiate_exit_block)
+
+ assert not pre_state.validator_registry[validator_index].initiated_exit
+ assert post_state.validator_registry[validator_index].initiated_exit
+ assert post_state.validator_registry[validator_index].exit_epoch == spec.FAR_FUTURE_EPOCH
+
+ #
+ # Process within epoch transition
+ #
+ exit_block = build_empty_block_for_next_slot(post_state)
+ exit_block.slot += spec.SLOTS_PER_EPOCH
+ state_transition(post_state, exit_block)
+
+ assert post_state.validator_registry[validator_index].exit_epoch < spec.FAR_FUTURE_EPOCH
+
+ return pre_state, [initiate_exit_block, exit_block], post_state
+
+
+def test_no_exit_churn_too_long_since_change(state):
+ pre_state = deepcopy(state)
+ validator_index = get_active_validator_indices(
+ pre_state.validator_registry,
+ get_current_epoch(pre_state)
+ )[-1]
+
+ #
+ # setup pre_state
+ #
+ # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit
+ pre_state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH
+ # artificially trigger registry update at next epoch transition
+ force_registry_change_at_next_epoch(pre_state)
+ # make epochs since registry update greater than LATEST_SLASHED_EXIT_LENGTH
+ pre_state.validator_registry_update_epoch = (
+ get_current_epoch(pre_state) - spec.LATEST_SLASHED_EXIT_LENGTH
+ )
+ # set validator to have previously initiated exit
+ pre_state.validator_registry[validator_index].initiated_exit = True
+
+ post_state = deepcopy(pre_state)
+
+ #
+ # Process registry change but ensure no exit
+ #
+ block = build_empty_block_for_next_slot(post_state)
+ block.slot += spec.SLOTS_PER_EPOCH
+ state_transition(post_state, block)
+
+ assert post_state.validator_registry_update_epoch == get_current_epoch(post_state) - 1
+ assert post_state.validator_registry[validator_index].exit_epoch == spec.FAR_FUTURE_EPOCH
+
+ return pre_state, [block], post_state
+
+
+def test_transfer(state):
+ pre_state = deepcopy(state)
+ current_epoch = get_current_epoch(pre_state)
+ sender_index = get_active_validator_indices(pre_state.validator_registry, current_epoch)[-1]
+ recipient_index = get_active_validator_indices(pre_state.validator_registry, current_epoch)[0]
+ transfer_pubkey = pubkeys[-1]
+ transfer_privkey = privkeys[-1]
+ amount = get_balance(pre_state, sender_index)
+ pre_transfer_recipient_balance = get_balance(pre_state, recipient_index)
+ transfer = Transfer(
+ sender=sender_index,
+ recipient=recipient_index,
+ amount=amount,
+ fee=0,
+ slot=pre_state.slot + 1,
+ pubkey=transfer_pubkey,
+ signature=EMPTY_SIGNATURE,
+ )
+ transfer.signature = bls.sign(
+ message_hash=signed_root(transfer),
+ privkey=transfer_privkey,
+ domain=get_domain(
+ fork=pre_state.fork,
+ epoch=get_current_epoch(pre_state),
+ domain_type=spec.DOMAIN_TRANSFER,
+ )
+ )
+
+ # ensure withdrawal_credentials reproducable
+ pre_state.validator_registry[sender_index].withdrawal_credentials = (
+ spec.BLS_WITHDRAWAL_PREFIX_BYTE + hash(transfer_pubkey)[1:]
+ )
+ # un-activate so validator can transfer
+ pre_state.validator_registry[sender_index].activation_epoch = spec.FAR_FUTURE_EPOCH
+
+ post_state = deepcopy(pre_state)
+ #
+ # Add to state via block transition
+ #
+ block = build_empty_block_for_next_slot(post_state)
+ block.body.transfers.append(transfer)
+ state_transition(post_state, block)
+
+ sender_balance = get_balance(post_state, sender_index)
+ recipient_balance = get_balance(post_state, recipient_index)
+ assert sender_balance == 0
+ assert recipient_balance == pre_transfer_recipient_balance + amount
+
+ return pre_state, [block], post_state
+
+
+def test_ejection(state):
+ pre_state = deepcopy(state)
+
+ current_epoch = get_current_epoch(pre_state)
+ validator_index = get_active_validator_indices(pre_state.validator_registry, current_epoch)[-1]
+
+ assert pre_state.validator_registry[validator_index].exit_epoch == spec.FAR_FUTURE_EPOCH
+
+ # set validator balance to below ejection threshold
+ set_balance(pre_state, validator_index, spec.EJECTION_BALANCE - 1)
+
+ post_state = deepcopy(pre_state)
+ #
+ # trigger epoch transition
+ #
+ block = build_empty_block_for_next_slot(post_state)
+ block.slot += spec.SLOTS_PER_EPOCH
+ state_transition(post_state, block)
+
+ assert post_state.validator_registry[validator_index].initiated_exit == True
+
+ return pre_state, [block], post_state
+
+
+def test_historical_batch(state):
+ pre_state = deepcopy(state)
+ pre_state.slot += spec.SLOTS_PER_HISTORICAL_ROOT - (pre_state.slot % spec.SLOTS_PER_HISTORICAL_ROOT) - 1
+
+ post_state = deepcopy(pre_state)
+
+ block = build_empty_block_for_next_slot(post_state)
+
+ state_transition(post_state, block)
+
+ assert post_state.slot == block.slot
+ assert get_current_epoch(post_state) % (spec.SLOTS_PER_HISTORICAL_ROOT // spec.SLOTS_PER_EPOCH) == 0
+ assert len(post_state.historical_roots) == len(pre_state.historical_roots) + 1
+
+ return pre_state, [block], post_state
diff --git a/utils/__init__.py b/utils/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/utils/phase0/__init__.py b/utils/phase0/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/utils/phase0/bls_stub.py b/utils/phase0/bls_stub.py
new file mode 100644
index 000000000..108c4ef71
--- /dev/null
+++ b/utils/phase0/bls_stub.py
@@ -0,0 +1,12 @@
+
+
+def bls_verify(pubkey, message_hash, signature, domain):
+ return True
+
+
+def bls_verify_multiple(pubkeys, message_hashes, signature, domain):
+ return True
+
+
+def bls_aggregate_pubkeys(pubkeys):
+ return b'\x42' * 96
diff --git a/utils/phase0/hash_function.py b/utils/phase0/hash_function.py
new file mode 100644
index 000000000..3fee63d82
--- /dev/null
+++ b/utils/phase0/hash_function.py
@@ -0,0 +1,6 @@
+from hashlib import sha256
+# from eth_utils import keccak
+
+
+def hash(x): return sha256(x).digest()
+# def hash(x): return keccak(x)
diff --git a/utils/phase0/jsonize.py b/utils/phase0/jsonize.py
new file mode 100644
index 000000000..816192ec6
--- /dev/null
+++ b/utils/phase0/jsonize.py
@@ -0,0 +1,52 @@
+from .minimal_ssz import hash_tree_root
+
+
+def jsonize(value, typ, include_hash_tree_roots=False):
+ if isinstance(typ, str) and typ[:4] == 'uint':
+ return value
+ elif typ == 'bool':
+ assert value in (True, False)
+ return value
+ elif isinstance(typ, list):
+ return [jsonize(element, typ[0], include_hash_tree_roots) for element in value]
+ elif isinstance(typ, str) and typ[:4] == 'byte':
+ return '0x' + value.hex()
+ elif hasattr(typ, 'fields'):
+ ret = {}
+ for field, subtype in typ.fields.items():
+ ret[field] = jsonize(getattr(value, field), subtype, include_hash_tree_roots)
+ if include_hash_tree_roots:
+ ret[field + "_hash_tree_root"] = '0x' + hash_tree_root(getattr(value, field), subtype).hex()
+ if include_hash_tree_roots:
+ ret["hash_tree_root"] = '0x' + hash_tree_root(value, typ).hex()
+ return ret
+ else:
+ print(value, typ)
+ raise Exception("Type not recognized")
+
+
+def dejsonize(json, typ):
+ if isinstance(typ, str) and typ[:4] == 'uint':
+ return json
+ elif typ == 'bool':
+ assert json in (True, False)
+ return json
+ elif isinstance(typ, list):
+ return [dejsonize(element, typ[0]) for element in json]
+ elif isinstance(typ, str) and typ[:4] == 'byte':
+ return bytes.fromhex(json[2:])
+ elif hasattr(typ, 'fields'):
+ temp = {}
+ for field, subtype in typ.fields.items():
+ temp[field] = dejsonize(json[field], subtype)
+ if field + "_hash_tree_root" in json:
+ assert(json[field + "_hash_tree_root"][2:] ==
+ hash_tree_root(temp[field], subtype).hex())
+ ret = typ(**temp)
+ if "hash_tree_root" in json:
+ assert(json["hash_tree_root"][2:] ==
+ hash_tree_root(ret, typ).hex())
+ return ret
+ else:
+ print(json, typ)
+ raise Exception("Type not recognized")
diff --git a/utils/phase0/merkle_minimal.py b/utils/phase0/merkle_minimal.py
new file mode 100644
index 000000000..7c5483de3
--- /dev/null
+++ b/utils/phase0/merkle_minimal.py
@@ -0,0 +1,30 @@
+from .hash_function import hash
+
+
+zerohashes = [b'\x00' * 32]
+for layer in range(1, 32):
+ zerohashes.append(hash(zerohashes[layer - 1] + zerohashes[layer - 1]))
+
+
+# Compute a Merkle root of a right-zerobyte-padded 2**32 sized tree
+def calc_merkle_tree_from_leaves(values):
+ values = list(values)
+ tree = [values[::]]
+ for h in range(32):
+ if len(values) % 2 == 1:
+ values.append(zerohashes[h])
+ values = [hash(values[i] + values[i + 1]) for i in range(0, len(values), 2)]
+ tree.append(values[::])
+ return tree
+
+
+def get_merkle_root(values):
+ return calc_merkle_tree_from_leaves(values)[-1][0]
+
+
+def get_merkle_proof(tree, item_index):
+ proof = []
+ for i in range(32):
+ subindex = (item_index // 2**i) ^ 1
+ proof.append(tree[i][subindex] if subindex < len(tree[i]) else zerohashes[i])
+ return proof
diff --git a/utils/phase0/minimal_ssz.py b/utils/phase0/minimal_ssz.py
new file mode 100644
index 000000000..c4828d08f
--- /dev/null
+++ b/utils/phase0/minimal_ssz.py
@@ -0,0 +1,213 @@
+from .hash_function import hash
+
+
+BYTES_PER_CHUNK = 32
+BYTES_PER_LENGTH_PREFIX = 4
+ZERO_CHUNK = b'\x00' * BYTES_PER_CHUNK
+
+
+def SSZType(fields):
+ class SSZObject():
+ def __init__(self, **kwargs):
+ for f in fields:
+ if f not in kwargs:
+ raise Exception("Missing constructor argument: %s" % f)
+ setattr(self, f, kwargs[f])
+
+ def __eq__(self, other):
+ return (
+ self.fields == other.fields and
+ self.serialize() == other.serialize()
+ )
+
+ def __hash__(self):
+ return int.from_bytes(self.hash_tree_root(), byteorder="little")
+
+ def __str__(self):
+ output = []
+ for field in self.fields:
+ output.append(f'{field}: {getattr(self, field)}')
+ return "\n".join(output)
+
+ def serialize(self):
+ return serialize_value(self, self.__class__)
+
+ def hash_tree_root(self):
+ return hash_tree_root(self, self.__class__)
+
+ SSZObject.fields = fields
+ return SSZObject
+
+
+class Vector():
+ def __init__(self, items):
+ self.items = items
+ self.length = len(items)
+
+ def __getitem__(self, key):
+ return self.items[key]
+
+ def __setitem__(self, key, value):
+ self.items[key] = value
+
+ def __iter__(self):
+ return iter(self.items)
+
+ def __len__(self):
+ return self.length
+
+
+def is_basic(typ):
+ return isinstance(typ, str) and (typ[:4] in ('uint', 'bool') or typ == 'byte')
+
+
+def is_constant_sized(typ):
+ if is_basic(typ):
+ return True
+ elif isinstance(typ, list) and len(typ) == 1:
+ return is_constant_sized(typ[0])
+ elif isinstance(typ, list) and len(typ) == 2:
+ return False
+ elif isinstance(typ, str) and typ[:5] == 'bytes':
+ return len(typ) > 5
+ elif hasattr(typ, 'fields'):
+ for subtype in typ.fields.values():
+ if not is_constant_sized(subtype):
+ return False
+ return True
+ else:
+ raise Exception("Type not recognized")
+
+
+def coerce_to_bytes(x):
+ if isinstance(x, str):
+ o = x.encode('utf-8')
+ assert len(o) == len(x)
+ return o
+ elif isinstance(x, bytes):
+ return x
+ else:
+ raise Exception("Expecting bytes")
+
+
+def serialize_value(value, typ=None):
+ if typ is None:
+ typ = infer_type(value)
+ if isinstance(typ, str) and typ[:4] == 'uint':
+ length = int(typ[4:])
+ assert length in (8, 16, 32, 64, 128, 256)
+ return value.to_bytes(length // 8, 'little')
+ elif typ == 'bool':
+ assert value in (True, False)
+ return b'\x01' if value is True else b'\x00'
+ elif (isinstance(typ, list) and len(typ) == 1) or typ == 'bytes':
+ serialized_bytes = coerce_to_bytes(value) if typ == 'bytes' else b''.join([serialize_value(element, typ[0]) for element in value])
+ assert len(serialized_bytes) < 2**(8 * BYTES_PER_LENGTH_PREFIX)
+ serialized_length = len(serialized_bytes).to_bytes(BYTES_PER_LENGTH_PREFIX, 'little')
+ return serialized_length + serialized_bytes
+ elif isinstance(typ, list) and len(typ) == 2:
+ assert len(value) == typ[1]
+ return b''.join([serialize_value(element, typ[0]) for element in value])
+ elif isinstance(typ, str) and len(typ) > 5 and typ[:5] == 'bytes':
+ assert len(value) == int(typ[5:]), (value, int(typ[5:]))
+ return coerce_to_bytes(value)
+ elif hasattr(typ, 'fields'):
+ serialized_bytes = b''.join([serialize_value(getattr(value, field), subtype) for field, subtype in typ.fields.items()])
+ if is_constant_sized(typ):
+ return serialized_bytes
+ else:
+ assert len(serialized_bytes) < 2**(8 * BYTES_PER_LENGTH_PREFIX)
+ serialized_length = len(serialized_bytes).to_bytes(BYTES_PER_LENGTH_PREFIX, 'little')
+ return serialized_length + serialized_bytes
+ else:
+ print(value, typ)
+ raise Exception("Type not recognized")
+
+
+def chunkify(bytez):
+ bytez += b'\x00' * (-len(bytez) % BYTES_PER_CHUNK)
+ return [bytez[i:i + 32] for i in range(0, len(bytez), 32)]
+
+
+def pack(values, subtype):
+ return chunkify(b''.join([serialize_value(value, subtype) for value in values]))
+
+
+def is_power_of_two(x):
+ return x > 0 and x & (x - 1) == 0
+
+
+def merkleize(chunks):
+ tree = chunks[::]
+ while not is_power_of_two(len(tree)):
+ tree.append(ZERO_CHUNK)
+ tree = [ZERO_CHUNK] * len(tree) + tree
+ for i in range(len(tree) // 2 - 1, 0, -1):
+ tree[i] = hash(tree[i * 2] + tree[i * 2 + 1])
+ return tree[1]
+
+
+def mix_in_length(root, length):
+ return hash(root + length.to_bytes(32, 'little'))
+
+
+def infer_type(value):
+ if hasattr(value.__class__, 'fields'):
+ return value.__class__
+ elif isinstance(value, Vector):
+ return [infer_type(value[0]) if len(value) > 0 else 'uint64', len(value)]
+ elif isinstance(value, list):
+ return [infer_type(value[0])] if len(value) > 0 else ['uint64']
+ elif isinstance(value, (bytes, str)):
+ return 'bytes'
+ elif isinstance(value, int):
+ return 'uint64'
+ else:
+ raise Exception("Failed to infer type")
+
+
+def hash_tree_root(value, typ=None):
+ if typ is None:
+ typ = infer_type(value)
+ if is_basic(typ):
+ return merkleize(pack([value], typ))
+ elif isinstance(typ, list) and len(typ) == 1 and is_basic(typ[0]):
+ return mix_in_length(merkleize(pack(value, typ[0])), len(value))
+ elif isinstance(typ, list) and len(typ) == 1 and not is_basic(typ[0]):
+ return mix_in_length(merkleize([hash_tree_root(element, typ[0]) for element in value]), len(value))
+ elif isinstance(typ, list) and len(typ) == 2 and is_basic(typ[0]):
+ assert len(value) == typ[1]
+ return merkleize(pack(value, typ[0]))
+ elif typ == 'bytes':
+ return mix_in_length(merkleize(chunkify(coerce_to_bytes(value))), len(value))
+ elif isinstance(typ, str) and typ[:5] == 'bytes' and len(typ) > 5:
+ assert len(value) == int(typ[5:])
+ return merkleize(chunkify(coerce_to_bytes(value)))
+ elif isinstance(typ, list) and len(typ) == 2 and not is_basic(typ[0]):
+ return merkleize([hash_tree_root(element, typ[0]) for element in value])
+ elif hasattr(typ, 'fields'):
+ return merkleize([hash_tree_root(getattr(value, field), subtype) for field, subtype in typ.fields.items()])
+ else:
+ raise Exception("Type not recognized")
+
+
+def truncate(container):
+ field_keys = list(container.fields.keys())
+ truncated_fields = {
+ key: container.fields[key]
+ for key in field_keys[:-1]
+ }
+ truncated_class = SSZType(truncated_fields)
+ kwargs = {
+ field: getattr(container, field)
+ for field in field_keys[:-1]
+ }
+ return truncated_class(**kwargs)
+
+
+def signed_root(container):
+ return hash_tree_root(truncate(container))
+
+
+def serialize(ssz_object):
+ return getattr(ssz_object, 'serialize')()
diff --git a/utils/phase0/state_transition.py b/utils/phase0/state_transition.py
new file mode 100644
index 000000000..cfd941c42
--- /dev/null
+++ b/utils/phase0/state_transition.py
@@ -0,0 +1,113 @@
+from . import spec
+
+
+from typing import ( # noqa: F401
+ Any,
+ Callable,
+ List,
+ NewType,
+ Tuple,
+)
+
+from .spec import (
+ BeaconState,
+ BeaconBlock,
+)
+
+
+def expected_deposit_count(state: BeaconState) -> int:
+ return min(
+ spec.MAX_DEPOSITS,
+ state.latest_eth1_data.deposit_count - state.deposit_index
+ )
+
+
+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_transactions(state: BeaconState, block: BeaconBlock) -> None:
+ process_transaction_type(
+ state,
+ block.body.proposer_slashings,
+ spec.MAX_PROPOSER_SLASHINGS,
+ spec.process_proposer_slashing,
+ )
+
+ process_transaction_type(
+ state,
+ block.body.attester_slashings,
+ spec.MAX_ATTESTER_SLASHINGS,
+ spec.process_attester_slashing,
+ )
+
+ process_transaction_type(
+ state,
+ block.body.attestations,
+ spec.MAX_ATTESTATIONS,
+ spec.process_attestation,
+ )
+
+ assert len(block.body.deposits) == expected_deposit_count(state)
+ process_transaction_type(
+ state,
+ block.body.deposits,
+ spec.MAX_DEPOSITS,
+ spec.process_deposit,
+ )
+
+ process_transaction_type(
+ state,
+ block.body.voluntary_exits,
+ spec.MAX_VOLUNTARY_EXITS,
+ spec.process_voluntary_exit,
+ )
+
+ assert len(block.body.transfers) == len(set(block.body.transfers))
+ process_transaction_type(
+ state,
+ block.body.transfers,
+ spec.MAX_TRANSFERS,
+ spec.process_transfer,
+ )
+
+
+def process_block(state: BeaconState,
+ block: BeaconBlock,
+ verify_state_root: bool=False) -> None:
+ spec.process_block_header(state, block)
+ spec.process_randao(state, block)
+ spec.process_eth1_data(state, block)
+
+ process_transactions(state, block)
+ if verify_state_root:
+ spec.verify_block_state_root(state, block)
+
+
+def process_epoch_transition(state: BeaconState) -> None:
+ spec.update_justification_and_finalization(state)
+ spec.process_crosslinks(state)
+ spec.maybe_reset_eth1_period(state)
+ spec.apply_rewards(state)
+ spec.process_ejections(state)
+ spec.update_registry(state)
+ spec.process_slashings(state)
+ spec.process_exit_queue(state)
+ spec.finish_epoch_update(state)
+
+
+def state_transition(state: BeaconState,
+ block: BeaconBlock,
+ verify_state_root: bool=False) -> BeaconState:
+ while state.slot < block.slot:
+ spec.cache_state(state)
+ if (state.slot + 1) % spec.SLOTS_PER_EPOCH == 0:
+ process_epoch_transition(state)
+ spec.advance_slot(state)
+ if block.slot == state.slot:
+ process_block(state, block, verify_state_root)