Move pytests for faster dev iteration

test_libs/pyspec/README.md

@@ -7,6 +7,7 @@ With this executable spec,
  test-generators can easily create test-vectors for client implementations,
  and the spec itself can be verified to be consistent and coherent, through sanity tests implemented with pytest.
 
+
 ## Building
 
 All the dynamic parts of the spec can be build at once with `make pyspec`.
@@ -15,12 +16,42 @@ Alternatively, you can build a sub-set of the pyspec: `make phase0`.
 
 Or, to build a single file, specify the path, e.g. `make test_libs/pyspec/eth2spec/phase0/spec.py`
 
+
+## Py-tests
+
+These tests are not intended for client-consumption.
+These tests are sanity tests, to verify if the spec itself is consistent.
+
+### How to run tests
+
+#### Automated
+
+Run `make test` from the root of the spec repository.
+
+#### Manual
+
+From within the `pyspec` folder:
+
+Install dependencies:
+```bash
+python3 -m venv venv
+. venv/bin/activate
+pip3 install -r requirements.txt
+```
+Note: make sure to run `make pyspec` from the root of the specs repository,
+ to build the parts of the pyspec module derived from the markdown specs.
+
+Run the tests:
+```
+pytest -m minimal_config .
+```
+
+
 ## Contributing
 
 Contributions are welcome, but consider implementing your idea as part of the spec itself first.
 The pyspec is not a replacement.
-If you see opportunity to include any of the `pyspec/eth2spec/utils/` code in the spec,
- please submit an issue or PR.
+
 
 ## License
 

test_libs/pyspec/requirements.txt

@@ -2,3 +2,4 @@ eth-utils>=1.3.0,<2
 eth-typing>=2.1.0,<3.0.0
 pycryptodome==3.7.3
 py_ecc>=1.6.0
+pytest>=3.6,<3.7

test_libs/pyspec/setup.py

@@ -3,6 +3,7 @@ from setuptools import setup, find_packages
 setup(
     name='pyspec',
     packages=find_packages(),
+    tests_require=["pytest"],
     install_requires=[
         "eth-utils>=1.3.0,<2",
         "eth-typing>=2.1.0,<3.0.0",

test_libs/pyspec/tests/block_processing/test_process_attestation.py

@@ -0,0 +1,152 @@
+from copy import deepcopy
+import pytest
+
+import eth2spec.phase0.spec as spec
+
+from eth2spec.phase0.state_transition import (
+    state_transition,
+)
+from eth2spec.phase0.spec import (
+    get_current_epoch,
+    process_attestation,
+    slot_to_epoch,
+)
+from tests.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

test_libs/pyspec/tests/block_processing/test_process_attester_slashing.py

@@ -0,0 +1,114 @@
+from copy import deepcopy
+import pytest
+
+import eth2spec.phase0.spec as spec
+from eth2spec.phase0.spec import (
+    get_balance,
+    get_beacon_proposer_index,
+    process_attester_slashing,
+)
+from tests.helpers import (
+    get_valid_attester_slashing,
+)
+
+# mark entire file as 'attester_slashing'
+pytestmark = pytest.mark.attester_slashings
+
+
+def run_attester_slashing_processing(state, attester_slashing, valid=True):
+    """
+    Run ``process_attester_slashing`` returning the pre and post state.
+    If ``valid == False``, run expecting ``AssertionError``
+    """
+    post_state = deepcopy(state)
+
+    if not valid:
+        with pytest.raises(AssertionError):
+            process_attester_slashing(post_state, attester_slashing)
+        return state, None
+
+    process_attester_slashing(post_state, attester_slashing)
+
+    slashed_index = attester_slashing.attestation_1.custody_bit_0_indices[0]
+    slashed_validator = post_state.validator_registry[slashed_index]
+    assert slashed_validator.slashed
+    assert slashed_validator.exit_epoch < spec.FAR_FUTURE_EPOCH
+    assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH
+    # lost whistleblower reward
+    assert (
+        get_balance(post_state, slashed_index) <
+        get_balance(state, slashed_index)
+    )
+    proposer_index = get_beacon_proposer_index(state)
+    # gained whistleblower reward
+    assert (
+        get_balance(post_state, proposer_index) >
+        get_balance(state, proposer_index)
+    )
+
+    return state, post_state
+
+
+def test_success_double(state):
+    attester_slashing = get_valid_attester_slashing(state)
+
+    pre_state, post_state = run_attester_slashing_processing(state, attester_slashing)
+
+    return pre_state, attester_slashing, post_state
+
+
+def test_success_surround(state):
+    attester_slashing = get_valid_attester_slashing(state)
+
+    # set attestion1 to surround attestation 2
+    attester_slashing.attestation_1.data.source_epoch = attester_slashing.attestation_2.data.source_epoch - 1
+    attester_slashing.attestation_1.data.slot = attester_slashing.attestation_2.data.slot + spec.SLOTS_PER_EPOCH
+
+    pre_state, post_state = run_attester_slashing_processing(state, attester_slashing)
+
+    return pre_state, attester_slashing, post_state
+
+
+def test_same_data(state):
+    attester_slashing = get_valid_attester_slashing(state)
+
+    attester_slashing.attestation_1.data = attester_slashing.attestation_2.data
+
+    pre_state, post_state = run_attester_slashing_processing(state, attester_slashing, False)
+
+    return pre_state, attester_slashing, post_state
+
+
+def test_no_double_or_surround(state):
+    attester_slashing = get_valid_attester_slashing(state)
+
+    attester_slashing.attestation_1.data.slot += spec.SLOTS_PER_EPOCH
+
+    pre_state, post_state = run_attester_slashing_processing(state, attester_slashing, False)
+
+    return pre_state, attester_slashing, post_state
+
+
+def test_participants_already_slashed(state):
+    attester_slashing = get_valid_attester_slashing(state)
+
+    # set all indices to slashed
+    attestation_1 = attester_slashing.attestation_1
+    validator_indices = attestation_1.custody_bit_0_indices + attestation_1.custody_bit_1_indices
+    for index in validator_indices:
+        state.validator_registry[index].slashed = True
+
+    pre_state, post_state = run_attester_slashing_processing(state, attester_slashing, False)
+
+    return pre_state, attester_slashing, post_state
+
+
+def test_custody_bit_0_and_1(state):
+    attester_slashing = get_valid_attester_slashing(state)
+
+    attester_slashing.attestation_1.custody_bit_1_indices = (
+        attester_slashing.attestation_1.custody_bit_0_indices
+    )
+    pre_state, post_state = run_attester_slashing_processing(state, attester_slashing, False)
+
+    return pre_state, attester_slashing, post_state

test_libs/pyspec/tests/block_processing/test_process_block_header.py

@@ -0,0 +1,76 @@
+from copy import deepcopy
+import pytest
+
+
+from eth2spec.phase0.spec import (
+    get_beacon_proposer_index,
+    cache_state,
+    advance_slot,
+    process_block_header,
+)
+from tests.helpers import (
+    build_empty_block_for_next_slot,
+    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):
+    # use stub state to get proposer index of next slot
+    stub_state = deepcopy(state)
+    next_slot(stub_state)
+    proposer_index = get_beacon_proposer_index(stub_state)
+
+    # set proposer to slashed
+    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

test_libs/pyspec/tests/block_processing/test_process_deposit.py

@@ -0,0 +1,141 @@
+from copy import deepcopy
+import pytest
+
+import eth2spec.phase0.spec as spec
+
+from eth2spec.phase0.spec import (
+    get_balance,
+    ZERO_HASH,
+    process_deposit,
+)
+from tests.helpers import (
+    build_deposit,
+    privkeys,
+    pubkeys,
+)
+
+
+# mark entire file as 'deposits'
+pytestmark = pytest.mark.deposits
+
+
+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

test_libs/pyspec/tests/block_processing/test_process_proposer_slashing.py

@@ -0,0 +1,96 @@
+from copy import deepcopy
+import pytest
+
+import eth2spec.phase0.spec as spec
+from eth2spec.phase0.spec import (
+    get_balance,
+    get_current_epoch,
+    process_proposer_slashing,
+)
+from tests.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 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

test_libs/pyspec/tests/block_processing/test_voluntary_exit.py

@@ -0,0 +1,163 @@
+from copy import deepcopy
+import pytest
+
+import eth2spec.phase0.spec as spec
+
+from eth2spec.phase0.spec import (
+    get_active_validator_indices,
+    get_churn_limit,
+    get_current_epoch,
+    process_voluntary_exit,
+)
+from tests.helpers import (
+    build_voluntary_exit,
+    pubkey_to_privkey,
+)
+
+
+# mark entire file as 'voluntary_exits'
+pytestmark = pytest.mark.voluntary_exits
+
+
+def run_voluntary_exit_processing(state, voluntary_exit, valid=True):
+    """
+    Run ``process_voluntary_exit`` returning the pre and post state.
+    If ``valid == False``, run expecting ``AssertionError``
+    """
+    post_state = deepcopy(state)
+
+    if not valid:
+        with pytest.raises(AssertionError):
+            process_voluntary_exit(post_state, voluntary_exit)
+        return state, None
+
+    process_voluntary_exit(post_state, voluntary_exit)
+
+    validator_index = voluntary_exit.validator_index
+    assert state.validator_registry[validator_index].exit_epoch == spec.FAR_FUTURE_EPOCH
+    assert post_state.validator_registry[validator_index].exit_epoch < spec.FAR_FUTURE_EPOCH
+
+    return state, post_state
+
+
+def test_success(state):
+    # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit
+    state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH
+
+    current_epoch = get_current_epoch(state)
+    validator_index = get_active_validator_indices(state, current_epoch)[0]
+    privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey]
+
+    voluntary_exit = build_voluntary_exit(
+        state,
+        current_epoch,
+        validator_index,
+        privkey,
+    )
+
+    pre_state, post_state = run_voluntary_exit_processing(state, voluntary_exit)
+    return pre_state, voluntary_exit, post_state
+
+
+def test_success_exit_queue(state):
+    # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit
+    state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH
+
+    current_epoch = get_current_epoch(state)
+
+    # exit `MAX_EXITS_PER_EPOCH`
+    initial_indices = get_active_validator_indices(state, current_epoch)[:get_churn_limit(state)]
+    post_state = state
+    for index in initial_indices:
+        privkey = pubkey_to_privkey[state.validator_registry[index].pubkey]
+        voluntary_exit = build_voluntary_exit(
+            state,
+            current_epoch,
+            index,
+            privkey,
+        )
+
+        pre_state, post_state = run_voluntary_exit_processing(post_state, voluntary_exit)
+
+    # exit an additional validator
+    validator_index = get_active_validator_indices(state, current_epoch)[-1]
+    privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey]
+    voluntary_exit = build_voluntary_exit(
+        state,
+        current_epoch,
+        validator_index,
+        privkey,
+    )
+
+    pre_state, post_state = run_voluntary_exit_processing(post_state, voluntary_exit)
+
+    assert (
+        post_state.validator_registry[validator_index].exit_epoch ==
+        post_state.validator_registry[initial_indices[0]].exit_epoch + 1
+    )
+
+    return pre_state, voluntary_exit, post_state
+
+
+def test_validator_not_active(state):
+    current_epoch = get_current_epoch(state)
+    validator_index = get_active_validator_indices(state, current_epoch)[0]
+    privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey]
+
+    state.validator_registry[validator_index].activation_epoch = spec.FAR_FUTURE_EPOCH
+
+    #
+    # build and test voluntary exit
+    #
+    voluntary_exit = build_voluntary_exit(
+        state,
+        current_epoch,
+        validator_index,
+        privkey,
+    )
+
+    pre_state, post_state = run_voluntary_exit_processing(state, voluntary_exit, False)
+    return pre_state, voluntary_exit, post_state
+
+
+def test_validator_already_exited(state):
+    # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow validator able to exit
+    state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH
+
+    current_epoch = get_current_epoch(state)
+    validator_index = get_active_validator_indices(state, current_epoch)[0]
+    privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey]
+
+    # but validator already has exited
+    state.validator_registry[validator_index].exit_epoch = current_epoch + 2
+
+    voluntary_exit = build_voluntary_exit(
+        state,
+        current_epoch,
+        validator_index,
+        privkey,
+    )
+
+    pre_state, post_state = run_voluntary_exit_processing(state, voluntary_exit, False)
+    return pre_state, voluntary_exit, post_state
+
+
+def test_validator_not_active_long_enough(state):
+    current_epoch = get_current_epoch(state)
+    validator_index = get_active_validator_indices(state, current_epoch)[0]
+    privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey]
+
+    voluntary_exit = build_voluntary_exit(
+        state,
+        current_epoch,
+        validator_index,
+        privkey,
+    )
+
+    assert (
+        current_epoch - state.validator_registry[validator_index].activation_epoch <
+        spec.PERSISTENT_COMMITTEE_PERIOD
+    )
+
+    pre_state, post_state = run_voluntary_exit_processing(state, voluntary_exit, False)
+    return pre_state, voluntary_exit, post_state

test_libs/pyspec/tests/conftest.py

@@ -0,0 +1,70 @@
+import pytest
+
+from eth2spec.phase0 import spec
+
+from .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)

test_libs/pyspec/tests/helpers.py

@@ -0,0 +1,313 @@
+from copy import deepcopy
+
+from py_ecc import bls
+
+from eth2spec.phase0.state_transition import (
+    state_transition,
+)
+import eth2spec.phase0.spec as spec
+from eth2spec.utils.minimal_ssz import signing_root
+from eth2spec.phase0.spec import (
+    # constants
+    EMPTY_SIGNATURE,
+    ZERO_HASH,
+    # SSZ
+    Attestation,
+    AttestationData,
+    AttestationDataAndCustodyBit,
+    AttesterSlashing,
+    BeaconBlockHeader,
+    Deposit,
+    DepositData,
+    Eth1Data,
+    ProposerSlashing,
+    VoluntaryExit,
+    # functions
+    convert_to_indexed,
+    get_active_validator_indices,
+    get_attestation_participants,
+    get_block_root,
+    get_crosslink_committee_for_attestation,
+    get_current_epoch,
+    get_domain,
+    get_empty_block,
+    get_epoch_start_slot,
+    get_genesis_beacon_state,
+    slot_to_epoch,
+    verify_merkle_branch,
+    hash,
+)
+from eth2spec.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 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 = signing_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=signing_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=signing_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, 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=signing_root(header_1),
+        privkey=privkey,
+        domain=domain,
+    )
+    header_2.signature = bls.sign(
+        message_hash=signing_root(header_2),
+        privkey=privkey,
+        domain=domain,
+    )
+
+    return ProposerSlashing(
+        proposer_index=validator_index,
+        header_1=header_1,
+        header_2=header_2,
+    )
+
+
+def get_valid_attester_slashing(state):
+    attestation_1 = get_valid_attestation(state)
+    attestation_2 = deepcopy(attestation_1)
+    attestation_2.data.target_root = b'\x01' * 32
+
+    return AttesterSlashing(
+        attestation_1=convert_to_indexed(state, attestation_1),
+        attestation_2=convert_to_indexed(state, attestation_2),
+    )
+
+
+def get_valid_attestation(state, slot=None):
+    if slot is None:
+        slot = state.slot
+    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,
+        )
+    )
+
+
+def next_slot(state):
+    block = build_empty_block_for_next_slot(state)
+    state_transition(state, block)

test_libs/pyspec/tests/test_sanity.py

@@ -0,0 +1,445 @@
+from copy import deepcopy
+
+import pytest
+
+from py_ecc import bls
+import eth2spec.phase0.spec as spec
+
+from eth2spec.utils.minimal_ssz import signing_root
+from eth2spec.phase0.spec import (
+    # constants
+    EMPTY_SIGNATURE,
+    ZERO_HASH,
+    # SSZ
+    Deposit,
+    Transfer,
+    VoluntaryExit,
+    # functions
+    get_active_validator_indices,
+    get_balance,
+    get_beacon_proposer_index,
+    get_block_root,
+    get_current_epoch,
+    get_domain,
+    get_state_root,
+    advance_slot,
+    cache_state,
+    set_balance,
+    verify_merkle_branch,
+    hash,
+)
+from eth2spec.phase0.state_transition import (
+    state_transition,
+)
+from eth2spec.utils.merkle_minimal import (
+    calc_merkle_tree_from_leaves,
+    get_merkle_proof,
+    get_merkle_root,
+)
+from .helpers import (
+    build_deposit_data,
+    build_empty_block_for_next_slot,
+    get_valid_attestation,
+    get_valid_attester_slashing,
+    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].slashed
+
+    slashed_validator = test_state.validator_registry[validator_index]
+    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_attester_slashing(state):
+    test_state = deepcopy(state)
+    attester_slashing = get_valid_attester_slashing(state)
+    validator_index = attester_slashing.attestation_1.custody_bit_0_indices[0]
+
+    #
+    # Add to state via block transition
+    #
+    block = build_empty_block_for_next_slot(test_state)
+    block.body.attester_slashings.append(attester_slashing)
+    state_transition(test_state, block)
+
+    assert not state.validator_registry[validator_index].slashed
+
+    slashed_validator = test_state.validator_registry[validator_index]
+    assert slashed_validator.slashed
+    assert slashed_validator.exit_epoch < spec.FAR_FUTURE_EPOCH
+    assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH
+    # lost whistleblower reward
+    assert get_balance(test_state, validator_index) < get_balance(state, validator_index)
+
+    proposer_index = get_beacon_proposer_index(test_state)
+    # gained whistleblower reward
+    assert (
+        get_balance(test_state, proposer_index) >
+        get_balance(state, proposer_index)
+    )
+
+    return state, [block], test_state
+
+
+def test_deposit_in_block(state):
+    pre_state = deepcopy(state)
+    test_deposit_data_leaves = [ZERO_HASH] * len(pre_state.validator_registry)
+
+    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
+
+    proposer_index = get_beacon_proposer_index(test_state)
+    assert test_state.balances[proposer_index] > state.balances[proposer_index]
+
+    #
+    # 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,
+        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
+
+    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=signing_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 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,
+        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
+
+    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[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, current_epoch)[-1]
+    recipient_index = get_active_validator_indices(pre_state, 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=signing_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_balance_driven_status_transitions(state):
+    pre_state = deepcopy(state)
+
+    current_epoch = get_current_epoch(pre_state)
+    validator_index = get_active_validator_indices(pre_state, 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].exit_epoch < spec.FAR_FUTURE_EPOCH
+
+    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