From 129aa02cb3c2f9546578975d4b080ae0179517c3 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 Feb 2020 15:16:54 -0700
Subject: [PATCH 01/33] support tests with SLOTS_PER_EPOCH * 256 vals

---
 setup.py                                      |  9 +++
 specs/phase1/custody-game.md                  |  8 ++-
 tests/core/pyspec/eth2spec/test/context.py    |  2 +-
 .../eth2spec/test/helpers/attestations.py     |  9 +--
 .../core/pyspec/eth2spec/test/helpers/keys.py |  2 +-
 .../test_process_attestation.py               |  8 ++-
 ..._process_justification_and_finalization.py |  5 +-
 .../test_process_rewards_and_penalties.py     | 59 ++++++++-----------
 8 files changed, 55 insertions(+), 47 deletions(-)

diff --git a/setup.py b/setup.py
index 444489d2e..ce565592f 100644
--- a/setup.py
+++ b/setup.py
@@ -169,16 +169,25 @@ get_base_reward = cache_this(
     lambda state, index: (state.validators.hash_tree_root(), state.slot),
     _get_base_reward)
 
+
 _get_committee_count_at_slot = get_committee_count_at_slot
 get_committee_count_at_slot = cache_this(
     lambda state, epoch: (state.validators.hash_tree_root(), epoch),
     _get_committee_count_at_slot)
 
+
 _get_active_validator_indices = get_active_validator_indices
 get_active_validator_indices = cache_this(
     lambda state, epoch: (state.validators.hash_tree_root(), epoch),
     _get_active_validator_indices)
 
+
+_get_total_active_balance = get_total_active_balance
+get_total_active_balance = cache_this(
+    lambda state: (state.validators.hash_tree_root(), get_current_epoch(state)),
+    _get_total_active_balance)
+
+
 _get_beacon_committee = get_beacon_committee
 get_beacon_committee = cache_this(
     lambda state, slot, index: (state.validators.hash_tree_root(), state.randao_mixes.hash_tree_root(), slot, index),
diff --git a/specs/phase1/custody-game.md b/specs/phase1/custody-game.md
index 121f91f97..a267bd330 100644
--- a/specs/phase1/custody-game.md
+++ b/specs/phase1/custody-game.md
@@ -416,7 +416,13 @@ def process_reveal_deadlines(state: BeaconState) -> None:
     epoch = get_current_epoch(state)
     for index, validator in enumerate(state.validators):
         if get_custody_period_for_validator(ValidatorIndex(index), epoch) > validator.next_custody_secret_to_reveal:
-            slash_validator(state, ValidatorIndex(index))
+            # ------------------  WARNING  ----------------------- #
+            # UNSAFE REMOVAL OF SLASHING TO PRIORITIZE PHASE 0 CI  #
+            # Must find generic way to handle key reveals in tests #
+            # ---------------------------------------------------- #
+
+            # slash_validator(state, ValidatorIndex(index))
+            pass
 ```
 
 ### Final updates
diff --git a/tests/core/pyspec/eth2spec/test/context.py b/tests/core/pyspec/eth2spec/test/context.py
index 5338ccb9d..543aa59c2 100644
--- a/tests/core/pyspec/eth2spec/test/context.py
+++ b/tests/core/pyspec/eth2spec/test/context.py
@@ -76,7 +76,7 @@ def default_balances(spec):
     Helper method to create a series of default balances.
     Usage: `@with_custom_state(balances_fn=default_balances, ...)`
     """
-    num_validators = spec.SLOTS_PER_EPOCH * 8
+    num_validators = spec.SLOTS_PER_EPOCH * 256
     return [spec.MAX_EFFECTIVE_BALANCE] * num_validators
 
 
diff --git a/tests/core/pyspec/eth2spec/test/helpers/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
index 047966890..9e12582e0 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/attestations.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
@@ -1,7 +1,6 @@
 from typing import List
 
-from eth2spec.test.helpers.block import build_empty_block_for_next_slot, transition_unsigned_block, \
-    build_empty_block
+from eth2spec.test.helpers.block import build_empty_block_for_next_slot
 from eth2spec.test.helpers.keys import privkeys
 from eth2spec.utils import bls
 from eth2spec.utils.ssz.ssz_typing import Bitlist
@@ -126,8 +125,6 @@ def fill_aggregate_attestation(spec, state, attestation, signed=False):
 
 
 def add_attestations_to_state(spec, state, attestations, slot):
-    block = build_empty_block(spec, state, slot)
+    spec.process_slots(state, slot)
     for attestation in attestations:
-        block.body.attestations.append(attestation)
-    spec.process_slots(state, block.slot)
-    transition_unsigned_block(spec, state, block)
+        spec.process_attestation(state, attestation)
diff --git a/tests/core/pyspec/eth2spec/test/helpers/keys.py b/tests/core/pyspec/eth2spec/test/helpers/keys.py
index 23bb95131..7f7820d3a 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/keys.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/keys.py
@@ -1,6 +1,6 @@
 from py_ecc.bls import G2ProofOfPossession as bls
 from eth2spec.phase0 import spec
 
-privkeys = [i + 1 for i in range(spec.SLOTS_PER_EPOCH * 16)]
+privkeys = [i + 1 for i in range(spec.SLOTS_PER_EPOCH * 256)]
 pubkeys = [bls.PrivToPub(privkey) for privkey in privkeys]
 pubkey_to_privkey = {pubkey: privkey for privkey, pubkey in zip(privkeys, pubkeys)}
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
index 7937614a4..64a64c72d 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
@@ -153,9 +153,11 @@ def test_wrong_index_for_committee_signature(spec, state):
 @spec_state_test
 @never_bls
 def test_wrong_index_for_slot(spec, state):
-    committees_per_slot = spec.get_committee_count_at_slot(state, state.slot)
-    assert committees_per_slot < spec.MAX_COMMITTEES_PER_SLOT
-    index = committees_per_slot
+    while spec.get_committee_count_at_slot(state, state.slot) >= spec.MAX_COMMITTEES_PER_SLOT:
+        state.validators = state.validators[:len(state.validators) // 2]
+        state.balances = state.balances[:len(state.balances) // 2]
+
+    index = spec.MAX_COMMITTEES_PER_SLOT - 1
 
     attestation = get_valid_attestation(spec, state)
     state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_justification_and_finalization.py b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_justification_and_finalization.py
index 917c06e3d..6fc4e30cb 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_justification_and_finalization.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_justification_and_finalization.py
@@ -46,9 +46,10 @@ def add_mock_attestations(spec, state, epoch, source, target, sufficient_support
                 else:
                     break
 
-            # remove just one attester to make the marginal support insufficient
+            # remove 1/5th of attesters so that support is insufficient
             if not sufficient_support:
-                aggregation_bits[aggregation_bits.index(1)] = 0
+                for i in range(max(len(committee) // 5, 1)):
+                    aggregation_bits[i] = 0
 
             attestations.append(spec.PendingAttestation(
                 aggregation_bits=aggregation_bits,
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py
index fa394df56..7cdeb16d9 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py
@@ -18,6 +18,27 @@ def run_process_rewards_and_penalties(spec, state):
     yield from run_epoch_processing_with(spec, state, 'process_rewards_and_penalties')
 
 
+def prepare_state_with_full_attestations(spec, state):
+    attestations = []
+    for slot in range(spec.SLOTS_PER_EPOCH + spec.MIN_ATTESTATION_INCLUSION_DELAY):
+        # create an attestation for each index in each slot in epoch
+        if slot < spec.SLOTS_PER_EPOCH:
+            for committee_index in range(spec.get_committee_count_at_slot(state, slot)):
+                attestation = get_valid_attestation(spec, state, index=committee_index, signed=True)
+                attestations.append(attestation)
+        # fill each created slot in state after inclusion delay
+        if slot - spec.MIN_ATTESTATION_INCLUSION_DELAY >= 0:
+            inclusion_slot = slot - spec.MIN_ATTESTATION_INCLUSION_DELAY
+            include_attestations = [att for att in attestations if att.data.slot == inclusion_slot]
+            add_attestations_to_state(spec, state, include_attestations, state.slot)
+        next_slot(spec, state)
+
+    assert spec.compute_epoch_at_slot(state.slot) == spec.GENESIS_EPOCH + 1
+    assert len(state.previous_epoch_attestations) == len(attestations)
+
+    return attestations
+
+
 @with_all_phases
 @spec_state_test
 def test_genesis_epoch_no_attestations_no_penalties(spec, state):
@@ -57,25 +78,6 @@ def test_genesis_epoch_full_attestations_no_rewards(spec, state):
         assert state.balances[index] == pre_state.balances[index]
 
 
-def prepare_state_with_full_attestations(spec, state):
-    attestations = []
-    for slot in range(spec.SLOTS_PER_EPOCH + spec.MIN_ATTESTATION_INCLUSION_DELAY):
-        # create an attestation for each slot in epoch
-        if slot < spec.SLOTS_PER_EPOCH:
-            attestation = get_valid_attestation(spec, state, signed=True)
-            attestations.append(attestation)
-        # fill each created slot in state after inclusion delay
-        if slot - spec.MIN_ATTESTATION_INCLUSION_DELAY >= 0:
-            include_att = attestations[slot - spec.MIN_ATTESTATION_INCLUSION_DELAY]
-            add_attestations_to_state(spec, state, [include_att], state.slot)
-        next_slot(spec, state)
-
-    assert spec.compute_epoch_at_slot(state.slot) == spec.GENESIS_EPOCH + 1
-    assert len(state.previous_epoch_attestations) == spec.SLOTS_PER_EPOCH
-
-    return attestations
-
-
 @with_all_phases
 @spec_state_test
 def test_full_attestations(spec, state):
@@ -86,7 +88,7 @@ def test_full_attestations(spec, state):
     yield from run_process_rewards_and_penalties(spec, state)
 
     attesting_indices = spec.get_unslashed_attesting_indices(state, attestations)
-    assert len(attesting_indices) > 0
+    assert len(attesting_indices) == len(pre_state.validators)
     for index in range(len(pre_state.validators)):
         if index in attesting_indices:
             assert state.balances[index] > pre_state.balances[index]
@@ -173,18 +175,7 @@ def test_duplicate_attestation(spec, state):
 @spec_state_test
 # Case when some eligible attestations are slashed. Modifies attesting_balance and consequently rewards/penalties.
 def test_attestations_some_slashed(spec, state):
-    attestations = []
-    for slot in range(spec.SLOTS_PER_EPOCH + spec.MIN_ATTESTATION_INCLUSION_DELAY):
-        # create an attestation for each slot in epoch
-        if slot < spec.SLOTS_PER_EPOCH:
-            attestation = get_valid_attestation(spec, state, signed=True)
-            attestations.append(attestation)
-        # fill each created slot in state after inclusion delay
-        if slot - spec.MIN_ATTESTATION_INCLUSION_DELAY >= 0:
-            include_att = attestations[slot - spec.MIN_ATTESTATION_INCLUSION_DELAY]
-            add_attestations_to_state(spec, state, [include_att], state.slot)
-        next_slot(spec, state)
-
+    attestations = prepare_state_with_full_attestations(spec, state)
     attesting_indices_before_slashings = list(spec.get_unslashed_attesting_indices(state, attestations))
 
     # Slash maximum amount of validators allowed per epoch.
@@ -192,7 +183,7 @@ def test_attestations_some_slashed(spec, state):
         spec.slash_validator(state, attesting_indices_before_slashings[i])
 
     assert spec.compute_epoch_at_slot(state.slot) == spec.GENESIS_EPOCH + 1
-    assert len(state.previous_epoch_attestations) == spec.SLOTS_PER_EPOCH
+    assert len(state.previous_epoch_attestations) == len(attestations)
 
     pre_state = deepcopy(state)
 
@@ -203,6 +194,8 @@ def test_attestations_some_slashed(spec, state):
     assert len(attesting_indices_before_slashings) - len(attesting_indices) == spec.MIN_PER_EPOCH_CHURN_LIMIT
     for index in range(len(pre_state.validators)):
         if index in attesting_indices:
+            # non-slashed attester should gain reward
             assert state.balances[index] > pre_state.balances[index]
         else:
+            # Slashed non-proposer attester should have penalty
             assert state.balances[index] < pre_state.balances[index]

From c1076097c37a7cb5260ca881b1da1cd66bc1b815 Mon Sep 17 00:00:00 2001
From: protolambda <proto@protolambda.com>
Date: Thu, 20 Feb 2020 11:33:42 -0800
Subject: [PATCH 02/33] wip work to improve tests

---
 .../test/fork_choice/test_on_attestation.py   |  4 +--
 .../pyspec/eth2spec/test/helpers/state.py     |  7 ++++
 .../test_process_attestation.py               | 34 +++++++++----------
 .../test_process_proposer_slashing.py         |  4 +--
 .../test_process_final_updates.py             |  4 ++-
 ..._process_justification_and_finalization.py |  7 ++--
 .../test_process_registry_updates.py          | 13 +++----
 .../test_process_slashings.py                 |  3 +-
 .../eth2spec/test/sanity/test_blocks.py       | 13 ++++---
 9 files changed, 52 insertions(+), 37 deletions(-)

diff --git a/tests/core/pyspec/eth2spec/test/fork_choice/test_on_attestation.py b/tests/core/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
index 09248944c..87a39a620 100644
--- a/tests/core/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
+++ b/tests/core/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
@@ -1,7 +1,7 @@
 from eth2spec.test.context import with_all_phases, spec_state_test
 from eth2spec.test.helpers.block import build_empty_block_for_next_slot
 from eth2spec.test.helpers.attestations import get_valid_attestation, sign_attestation
-from eth2spec.test.helpers.state import transition_to, state_transition_and_sign_block
+from eth2spec.test.helpers.state import transition_to, state_transition_and_sign_block, next_epoch
 
 
 def run_on_attestation(spec, state, store, attestation, valid=True):
@@ -179,7 +179,7 @@ def test_on_attestation_future_epoch(spec, state):
     spec.on_block(store, signed_block)
 
     # move state forward but not store
-    state.slot = block.slot + spec.SLOTS_PER_EPOCH
+    next_epoch(spec, state)
 
     attestation = get_valid_attestation(spec, state, slot=state.slot, signed=True)
     run_on_attestation(spec, state, store, attestation, False)
diff --git a/tests/core/pyspec/eth2spec/test/helpers/state.py b/tests/core/pyspec/eth2spec/test/helpers/state.py
index aad329ff4..5816785f7 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/state.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/state.py
@@ -14,6 +14,13 @@ def next_slot(spec, state):
     spec.process_slots(state, state.slot + 1)
 
 
+def next_slots(spec, state, slots):
+    """
+    Transition given slots forward.
+    """
+    spec.process_slots(state, state.slot + slots)
+
+
 def transition_to(spec, state, slot):
     """
     Transition to ``slot``.
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
index 64a64c72d..1dbdafec2 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
@@ -13,7 +13,7 @@ from eth2spec.test.helpers.attestations import (
     sign_attestation,
 )
 from eth2spec.test.helpers.state import (
-    next_epoch,
+    next_epoch, next_slots
 )
 from eth2spec.test.helpers.block import apply_empty_block
 from eth2spec.utils.ssz.ssz_typing import Bitlist
@@ -58,7 +58,7 @@ def run_attestation_processing(spec, state, attestation, valid=True):
 @spec_state_test
 def test_success(spec, state):
     attestation = get_valid_attestation(spec, state, signed=True)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     yield from run_attestation_processing(spec, state, attestation)
 
@@ -68,9 +68,9 @@ def test_success(spec, state):
 @with_custom_state(balances_fn=low_balances, threshold_fn=lambda spec: spec.EJECTION_BALANCE)
 @single_phase
 def test_success_multi_proposer_index_iterations(spec, state):
-    state.slot += spec.SLOTS_PER_EPOCH * 2
+    next_slots(spec, state, spec.SLOTS_PER_EPOCH * 2)
     attestation = get_valid_attestation(spec, state, signed=True)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     yield from run_attestation_processing(spec, state, attestation)
 
@@ -91,7 +91,7 @@ def test_success_previous_epoch(spec, state):
 @always_bls
 def test_invalid_attestation_signature(spec, state):
     attestation = get_valid_attestation(spec, state)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     yield from run_attestation_processing(spec, state, attestation, False)
 
@@ -120,7 +120,7 @@ def test_after_epoch_slots(spec, state):
 @with_all_phases
 @spec_state_test
 def test_old_source_epoch(spec, state):
-    state.slot = spec.SLOTS_PER_EPOCH * 5
+    next_slots(spec, state, spec.SLOTS_PER_EPOCH * 5)
     state.finalized_checkpoint.epoch = 2
     state.previous_justified_checkpoint.epoch = 3
     state.current_justified_checkpoint.epoch = 4
@@ -142,7 +142,7 @@ def test_old_source_epoch(spec, state):
 @always_bls
 def test_wrong_index_for_committee_signature(spec, state):
     attestation = get_valid_attestation(spec, state)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     attestation.data.index += 1
 
@@ -160,7 +160,7 @@ def test_wrong_index_for_slot(spec, state):
     index = spec.MAX_COMMITTEES_PER_SLOT - 1
 
     attestation = get_valid_attestation(spec, state)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     attestation.data.index = index
 
@@ -172,7 +172,7 @@ def test_wrong_index_for_slot(spec, state):
 @never_bls
 def test_invalid_index(spec, state):
     attestation = get_valid_attestation(spec, state)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     # off by one (with respect to valid range) on purpose
     attestation.data.index = spec.MAX_COMMITTEES_PER_SLOT
@@ -223,7 +223,7 @@ def test_future_target_epoch(spec, state):
     # manually add signature for correct participants
     attestation.signature = sign_aggregate_attestation(spec, state, attestation.data, participants)
 
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     yield from run_attestation_processing(spec, state, attestation, False)
 
@@ -232,7 +232,7 @@ def test_future_target_epoch(spec, state):
 @spec_state_test
 def test_new_source_epoch(spec, state):
     attestation = get_valid_attestation(spec, state)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     attestation.data.source.epoch += 1
 
@@ -245,7 +245,7 @@ def test_new_source_epoch(spec, state):
 @spec_state_test
 def test_source_root_is_target_root(spec, state):
     attestation = get_valid_attestation(spec, state)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     attestation.data.source.root = attestation.data.target.root
 
@@ -264,7 +264,7 @@ def test_invalid_current_source_root(spec, state):
     state.current_justified_checkpoint = spec.Checkpoint(epoch=4, root=b'\x32' * 32)
 
     attestation = get_valid_attestation(spec, state, slot=(spec.SLOTS_PER_EPOCH * 3) + 1)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     # Test logic sanity checks:
     assert state.current_justified_checkpoint.root != state.previous_justified_checkpoint.root
@@ -282,7 +282,7 @@ def test_invalid_current_source_root(spec, state):
 @spec_state_test
 def test_bad_source_root(spec, state):
     attestation = get_valid_attestation(spec, state)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     attestation.data.source.root = b'\x42' * 32
 
@@ -295,7 +295,7 @@ def test_bad_source_root(spec, state):
 @spec_state_test
 def test_empty_aggregation_bits(spec, state):
     attestation = get_valid_attestation(spec, state)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     attestation.aggregation_bits = Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE](
         *([0b0] * len(attestation.aggregation_bits)))
@@ -309,7 +309,7 @@ def test_empty_aggregation_bits(spec, state):
 @spec_state_test
 def test_too_many_aggregation_bits(spec, state):
     attestation = get_valid_attestation(spec, state, signed=True)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     # one too many bits
     attestation.aggregation_bits.append(0b0)
@@ -321,7 +321,7 @@ def test_too_many_aggregation_bits(spec, state):
 @spec_state_test
 def test_too_few_aggregation_bits(spec, state):
     attestation = get_valid_attestation(spec, state)
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     attestation.aggregation_bits = Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE](
         *([0b1] + [0b0] * (len(attestation.aggregation_bits) - 1)))
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_proposer_slashing.py b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_proposer_slashing.py
index 30b3c1fdd..ad910f227 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_proposer_slashing.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_proposer_slashing.py
@@ -2,7 +2,7 @@ from eth2spec.test.context import spec_state_test, expect_assertion_error, alway
 from eth2spec.test.helpers.block_header import sign_block_header
 from eth2spec.test.helpers.keys import privkeys
 from eth2spec.test.helpers.proposer_slashings import get_valid_proposer_slashing
-from eth2spec.test.helpers.state import get_balance
+from eth2spec.test.helpers.state import get_balance, next_epoch
 
 
 def run_proposer_slashing_processing(spec, state, proposer_slashing, valid=True):
@@ -135,7 +135,7 @@ def test_proposer_is_withdrawn(spec, state):
     proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True)
 
     # move 1 epoch into future, to allow for past withdrawable epoch
-    state.slot += spec.SLOTS_PER_EPOCH
+    next_epoch(spec, state)
     # set proposer withdrawable_epoch in past
     current_epoch = spec.get_current_epoch(state)
     proposer_index = proposer_slashing.proposer_index
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_final_updates.py b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_final_updates.py
index 58882a44f..2e71346aa 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_final_updates.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_final_updates.py
@@ -2,6 +2,7 @@ from eth2spec.test.context import spec_state_test, with_all_phases
 from eth2spec.test.phase_0.epoch_processing.run_epoch_process_base import (
     run_epoch_processing_with, run_epoch_processing_to
 )
+from eth2spec.test.helpers.state import transition_to
 
 
 def run_process_final_updates(spec, state):
@@ -13,7 +14,8 @@ def run_process_final_updates(spec, state):
 def test_eth1_vote_no_reset(spec, state):
     assert spec.SLOTS_PER_ETH1_VOTING_PERIOD > spec.SLOTS_PER_EPOCH
     # skip ahead to the end of the epoch
-    state.slot = spec.SLOTS_PER_EPOCH - 1
+    transition_to(spec, state, spec.SLOTS_PER_EPOCH - 1)
+
     for i in range(state.slot + 1):  # add a vote for each skipped slot.
         state.eth1_data_votes.append(
             spec.Eth1Data(deposit_root=b'\xaa' * 32,
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_justification_and_finalization.py b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_justification_and_finalization.py
index 6fc4e30cb..9f9e1c316 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_justification_and_finalization.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_justification_and_finalization.py
@@ -2,6 +2,7 @@ from eth2spec.test.context import spec_state_test, with_all_phases
 from eth2spec.test.phase_0.epoch_processing.run_epoch_process_base import (
     run_epoch_processing_with
 )
+from eth2spec.test.helpers.state import transition_to
 
 
 def run_process_just_and_fin(spec, state):
@@ -82,7 +83,7 @@ def put_checkpoints_in_block_roots(spec, state, checkpoints):
 
 def finalize_on_234(spec, state, epoch, sufficient_support):
     assert epoch > 4
-    state.slot = (spec.SLOTS_PER_EPOCH * epoch) - 1  # skip ahead to just before epoch
+    transition_to(spec, state, spec.SLOTS_PER_EPOCH * epoch - 1)  # skip ahead to just before epoch
 
     # 43210 -- epochs ago
     # 3210x -- justification bitfield indices
@@ -117,7 +118,7 @@ def finalize_on_234(spec, state, epoch, sufficient_support):
 
 def finalize_on_23(spec, state, epoch, sufficient_support):
     assert epoch > 3
-    state.slot = (spec.SLOTS_PER_EPOCH * epoch) - 1  # skip ahead to just before epoch
+    transition_to(spec, state, spec.SLOTS_PER_EPOCH * epoch - 1)  # skip ahead to just before epoch
 
     # 43210 -- epochs ago
     # 210xx  -- justification bitfield indices (pre shift)
@@ -195,7 +196,7 @@ def finalize_on_123(spec, state, epoch, sufficient_support):
 
 def finalize_on_12(spec, state, epoch, sufficient_support, messed_up_target):
     assert epoch > 2
-    state.slot = (spec.SLOTS_PER_EPOCH * epoch) - 1  # skip ahead to just before epoch
+    transition_to(spec, state, spec.SLOTS_PER_EPOCH * epoch - 1)  # skip ahead to just before epoch
 
     # 43210 -- epochs ago
     # 210xx  -- justification bitfield indices (pre shift)
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_registry_updates.py b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_registry_updates.py
index 526aba277..a5f4d9227 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_registry_updates.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_registry_updates.py
@@ -1,4 +1,4 @@
-from eth2spec.test.helpers.state import next_epoch
+from eth2spec.test.helpers.state import next_epoch, next_slots
 from eth2spec.test.context import spec_state_test, with_all_phases
 from eth2spec.test.phase_0.epoch_processing.run_epoch_process_base import run_epoch_processing_with
 
@@ -101,7 +101,7 @@ def test_activation_queue_sorting(spec, state):
     state.validators[mock_activations - 1].activation_eligibility_epoch = epoch
 
     # move state forward and finalize to allow for activations
-    state.slot += spec.SLOTS_PER_EPOCH * 3
+    next_slots(spec, state, spec.SLOTS_PER_EPOCH * 3)
     state.finalized_checkpoint.epoch = epoch + 1
 
     yield from run_process_registry_updates(spec, state)
@@ -113,10 +113,10 @@ def test_activation_queue_sorting(spec, state):
     # the second last is at the end of the queue, and did not make the churn,
     #  hence is not assigned an activation_epoch yet.
     assert state.validators[mock_activations - 2].activation_epoch == spec.FAR_FUTURE_EPOCH
-    # the one at churn_limit - 1 did not make it, it was out-prioritized
-    assert state.validators[churn_limit - 1].activation_epoch == spec.FAR_FUTURE_EPOCH
+    # the one at churn_limit did not make it, it was out-prioritized
+    assert state.validators[churn_limit].activation_epoch == spec.FAR_FUTURE_EPOCH
     # but the the one in front of the above did
-    assert state.validators[churn_limit - 2].activation_epoch != spec.FAR_FUTURE_EPOCH
+    assert state.validators[churn_limit - 1].activation_epoch != spec.FAR_FUTURE_EPOCH
 
 
 @with_all_phases
@@ -131,7 +131,8 @@ def test_activation_queue_efficiency(spec, state):
         state.validators[i].activation_eligibility_epoch = epoch + 1
 
     # move state forward and finalize to allow for activations
-    state.slot += spec.SLOTS_PER_EPOCH * 3
+    next_slots(spec, state, spec.SLOTS_PER_EPOCH * 3)
+
     state.finalized_checkpoint.epoch = epoch + 1
 
     # Run first registry update. Do not yield test vectors
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_slashings.py b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_slashings.py
index c58da5a4a..23c8ce11a 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_slashings.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_slashings.py
@@ -2,6 +2,7 @@ from eth2spec.test.context import spec_state_test, with_all_phases
 from eth2spec.test.phase_0.epoch_processing.run_epoch_process_base import (
     run_epoch_processing_with, run_epoch_processing_to
 )
+from eth2spec.test.helpers.state import next_epoch
 
 
 def run_process_slashings(spec, state):
@@ -79,7 +80,7 @@ def test_small_penalty(spec, state):
 @spec_state_test
 def test_scaled_penalties(spec, state):
     # skip to next epoch
-    state.slot = spec.SLOTS_PER_EPOCH
+    next_epoch(spec, state)
 
     # Also mock some previous slashings, so that we test to have the delta in the penalties computation.
     base = spec.EJECTION_BALANCE
diff --git a/tests/core/pyspec/eth2spec/test/sanity/test_blocks.py b/tests/core/pyspec/eth2spec/test/sanity/test_blocks.py
index 9027660ab..e533b3b0a 100644
--- a/tests/core/pyspec/eth2spec/test/sanity/test_blocks.py
+++ b/tests/core/pyspec/eth2spec/test/sanity/test_blocks.py
@@ -2,7 +2,7 @@ from copy import deepcopy
 
 from eth2spec.utils import bls
 
-from eth2spec.test.helpers.state import get_balance, state_transition_and_sign_block, next_slot
+from eth2spec.test.helpers.state import get_balance, state_transition_and_sign_block, next_slot, next_epoch
 from eth2spec.test.helpers.block import build_empty_block_for_next_slot, build_empty_block, sign_block, \
     transition_unsigned_block
 from eth2spec.test.helpers.keys import privkeys, pubkeys
@@ -11,7 +11,7 @@ from eth2spec.test.helpers.proposer_slashings import get_valid_proposer_slashing
 from eth2spec.test.helpers.attestations import get_valid_attestation
 from eth2spec.test.helpers.deposits import prepare_state_and_deposit
 
-from eth2spec.test.context import spec_state_test, with_all_phases, expect_assertion_error, always_bls
+from eth2spec.test.context import spec_state_test, with_all_phases, expect_assertion_error, always_bls, with_phases
 
 
 @with_all_phases
@@ -260,7 +260,8 @@ def test_proposer_after_inactive_index(spec, state):
     state.validators[inactive_index].exit_epoch = spec.get_current_epoch(state)
 
     # skip forward, get brand new proposers
-    state.slot = spec.SLOTS_PER_EPOCH * 2
+    next_epoch(spec, state)
+    next_epoch(spec, state)
     block = build_empty_block_for_next_slot(spec, state)
     state_transition_and_sign_block(spec, state, block)
 
@@ -372,7 +373,7 @@ def test_deposit_top_up(spec, state):
 @with_all_phases
 @spec_state_test
 def test_attestation(spec, state):
-    state.slot = spec.SLOTS_PER_EPOCH
+    next_epoch(spec, state)
 
     yield 'pre', state
 
@@ -399,7 +400,9 @@ def test_attestation(spec, state):
     assert spec.hash_tree_root(state.previous_epoch_attestations) == pre_current_attestations_root
 
 
-@with_all_phases
+# In phase1 a committee is computed for PERSISTENT_COMMITTEE_PERIOD slots ago,
+# exceeding the minimal-config randao mixes memory size.
+@with_phases(['phase0'])
 @spec_state_test
 def test_voluntary_exit(spec, state):
     validator_index = spec.get_active_validator_indices(

From aa451778f96183b4ca4bcdf27a952dfc6fc80ccf Mon Sep 17 00:00:00 2001
From: protolambda <proto@protolambda.com>
Date: Thu, 20 Feb 2020 11:34:37 -0800
Subject: [PATCH 03/33] work in progress test improvements

---
 tests/core/pyspec/eth2spec/test/context.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/core/pyspec/eth2spec/test/context.py b/tests/core/pyspec/eth2spec/test/context.py
index 543aa59c2..5338ccb9d 100644
--- a/tests/core/pyspec/eth2spec/test/context.py
+++ b/tests/core/pyspec/eth2spec/test/context.py
@@ -76,7 +76,7 @@ def default_balances(spec):
     Helper method to create a series of default balances.
     Usage: `@with_custom_state(balances_fn=default_balances, ...)`
     """
-    num_validators = spec.SLOTS_PER_EPOCH * 256
+    num_validators = spec.SLOTS_PER_EPOCH * 8
     return [spec.MAX_EFFECTIVE_BALANCE] * num_validators
 
 

From d414aac93352827aedcee2d66280296c13db3d16 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Thu, 6 Feb 2020 12:58:21 -0600
Subject: [PATCH 04/33] rework process_attestation and work through tests

---
 specs/phase1/beacon-chain.md                  | 70 ++++++++--------
 .../test_process_attestation.py               | 80 +++++++++++++++++++
 2 files changed, 114 insertions(+), 36 deletions(-)
 create mode 100644 tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py

diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index 78b3b3d25..bdf70c5bd 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -568,23 +568,23 @@ def process_block(state: BeaconState, block: BeaconBlock) -> None:
 def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
     # Verify that outstanding deposits are processed up to the maximum number of deposits
     assert len(body.deposits) == min(MAX_DEPOSITS, state.eth1_data.deposit_count - state.eth1_deposit_index)
-    
+
     def for_ops(operations: Sequence[Any], fn: Callable[[BeaconState, Any], None]) -> None:
         for operation in operations:
             fn(state, operation)
-    
+
     for_ops(body.proposer_slashings, process_proposer_slashing)
     for_ops(body.attester_slashings, process_attester_slashing)
-
     # New attestation processing
-    process_attestations(state, body, body.attestations)
-
+    for_ops(body.attestations, process_attestation)
     for_ops(body.deposits, process_deposit)
     for_ops(body.voluntary_exits, process_voluntary_exit)
 
     # See custody game spec.
     process_custody_game_operations(state, body)
 
+    process_crosslinks(state, body.shard_transitions, body.attestations)
+
     # TODO process_operations(body.shard_receipt_proofs, process_shard_receipt_proofs)
 ```
 
@@ -598,6 +598,7 @@ def validate_attestation(state: BeaconState, attestation: Attestation) -> None:
     assert data.index < get_committee_count_at_slot(state, data.slot)
     assert data.index < get_active_shard_count(state)
     assert data.target.epoch in (get_previous_epoch(state), get_current_epoch(state))
+    assert data.target.epoch == compute_epoch_at_slot(data.slot)
     assert data.slot + MIN_ATTESTATION_INCLUSION_DELAY <= state.slot <= data.slot + SLOTS_PER_EPOCH
 
     committee = get_beacon_committee(state, data.slot, data.index)
@@ -740,49 +741,46 @@ def process_crosslink_for_shard(state: BeaconState,
 
 ```python
 def process_crosslinks(state: BeaconState,
-                       block_body: BeaconBlockBody,
-                       attestations: Sequence[Attestation]) -> Set[Tuple[Shard, Root]]:
-    winners: Set[Tuple[Shard, Root]] = set()
+                       shard_transitions: Sequence[ShardTransition],
+                       attestations: Sequence[Attestation]) -> None:
     committee_count = get_committee_count_at_slot(state, state.slot)
     for committee_index in map(CommitteeIndex, range(committee_count)):
         shard = compute_shard_from_committee_index(state, committee_index, state.slot)
-        # All attestations in the block for this shard
+        # All attestations in the block for this committee/shard and current slot
         shard_attestations = [
             attestation for attestation in attestations
-            if get_shard(state, attestation) == shard and attestation.data.slot == state.slot
+            if attestation.data.index == committee_index and attestation.data.slot == state.slot
         ]
-        shard_transition = block_body.shard_transitions[shard]
+        shard_transition = shard_transitions[shard]
         winning_root = process_crosslink_for_shard(state, shard, shard_transition, shard_attestations)
         if winning_root != Root():
-            winners.add((shard, winning_root))
-    return winners
+            # Mark relevant pending attestations as creating a successful crosslink
+            for pending_attestation in state.current_epoch_attestations:
+                if (
+                    pending_attestation.slot == state.slot and pending_attestation
+                    and pending_attestation.data.index == committee_index
+                    and pending_attestation.data.shard_transition_root == winning_root
+                ):
+                    pending_attestation.crosslink_success = True
 ```
 
-###### `process_attestations`
+###### `process_attestation`
 
 ```python
-def process_attestations(state: BeaconState, block_body: BeaconBlockBody, attestations: Sequence[Attestation]) -> None:
-    # Basic validation
-    for attestation in attestations:
-        validate_attestation(state, attestation)
-
-    # Process crosslinks
-    winners = process_crosslinks(state, block_body, attestations)
-
-    # Store pending attestations for epoch processing
-    for attestation in attestations:
-        is_winning_transition = (get_shard(state, attestation), attestation.data.shard_transition_root) in winners
-        pending_attestation = PendingAttestation(
-            aggregation_bits=attestation.aggregation_bits,
-            data=attestation.data,
-            inclusion_delay=state.slot - attestation.data.slot,
-            crosslink_success=is_winning_transition and attestation.data.slot == state.slot,
-            proposer_index=get_beacon_proposer_index(state),
-        )
-        if attestation.data.target.epoch == get_current_epoch(state):
-            state.current_epoch_attestations.append(pending_attestation)
-        else:
-            state.previous_epoch_attestations.append(pending_attestation)
+def process_attestation(state: BeaconState, attestation: Attestation) -> None:
+    validate_attestation(state, attestation)
+    # Store pending attestation for epoch processing
+    pending_attestation = PendingAttestation(
+        aggregation_bits=attestation.aggregation_bits,
+        data=attestation.data,
+        inclusion_delay=state.slot - attestation.data.slot,
+        crosslink_success=False,  # To be filled in during process_crosslinks
+        proposer_index=get_beacon_proposer_index(state),
+    )
+    if attestation.data.target.epoch == get_current_epoch(state):
+        state.current_epoch_attestations.append(pending_attestation)
+    else:
+        state.previous_epoch_attestations.append(pending_attestation)
 ```
 
 ##### New Attester slashing processing
diff --git a/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py b/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py
new file mode 100644
index 000000000..875039c59
--- /dev/null
+++ b/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py
@@ -0,0 +1,80 @@
+from eth2spec.test.context import (
+    with_all_phases_except,
+    expect_assertion_error,
+    spec_state_test,
+    always_bls,
+)
+from eth2spec.test.helpers.attestations import (
+    get_valid_attestation,
+    sign_attestation,
+)
+
+from eth2spec.utils.ssz.ssz_typing import Bitlist
+
+
+def run_attestation_processing(spec, state, attestation, valid=True):
+    """
+    Run ``process_attestation``, yielding:
+      - pre-state ('pre')
+      - attestation ('attestation')
+      - post-state ('post').
+    If ``valid == False``, run expecting ``AssertionError``
+    """
+    # yield pre-state
+    yield 'pre', state
+
+    yield 'attestation', attestation
+
+    # If the attestation is invalid, processing is aborted, and there is no post-state.
+    if not valid:
+        expect_assertion_error(lambda: spec.process_attestation(state, attestation))
+        yield 'post', None
+        return
+
+    current_epoch_count = len(state.current_epoch_attestations)
+    previous_epoch_count = len(state.previous_epoch_attestations)
+
+    # process attestation
+    spec.process_attestation(state, attestation)
+
+    # Make sure the attestation has been processed
+    if attestation.data.target.epoch == spec.get_current_epoch(state):
+        assert len(state.current_epoch_attestations) == current_epoch_count + 1
+    else:
+        assert len(state.previous_epoch_attestations) == previous_epoch_count + 1
+
+    # yield post-state
+    yield 'post', state
+
+
+@with_all_phases_except(['phase0'])
+@spec_state_test
+@always_bls
+def test_success_empty_custody_bits_blocks(spec, state):
+    attestation = get_valid_attestation(spec, state)
+    attestation.custody_bits_blocks = []
+    sign_attestation(spec, state, attestation)
+
+    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+
+    yield from run_attestation_processing(spec, state, attestation)
+
+
+@with_all_phases_except(['phase0'])
+@spec_state_test
+@always_bls
+def test_fail_custody_bits_blocks_incorrect_slot(spec, state):
+    attestation = get_valid_attestation(spec, state)
+    committee = spec.get_beacon_committee(
+        state,
+        attestation.data.slot,
+        attestation.data.index,
+    )
+    bitlist = Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE]([0 for _ in range(len(committee))])
+    bitlist[0] = 1
+    attestation.custody_bits_blocks = [bitlist]
+    sign_attestation(spec, state, attestation)
+
+    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + 1
+
+    yield from run_attestation_processing(spec, state, attestation)
\ No newline at end of file

From 0a849acdceb0d3a617fbefcec119e0c061529266 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Sat, 8 Feb 2020 16:58:05 -0700
Subject: [PATCH 05/33] fix validator guide to show that block slashing is per
 slot rather than per epoch

---
 specs/phase0/validator.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/specs/phase0/validator.md b/specs/phase0/validator.md
index be151447d..901fb562d 100644
--- a/specs/phase0/validator.md
+++ b/specs/phase0/validator.md
@@ -495,13 +495,13 @@ Because Phase 0 does not have shards and thus does not have Shard Committees, th
 
 ### Proposer slashing
 
-To avoid "proposer slashings", a validator must not sign two conflicting [`BeaconBlock`](./beacon-chain.md#beaconblock) where conflicting is defined as two distinct blocks within the same epoch.
+To avoid "proposer slashings", a validator must not sign two conflicting [`BeaconBlock`](./beacon-chain.md#beaconblock) where conflicting is defined as two distinct blocks within the same slot.
 
-*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.*
+*In Phase 0, as long as the validator does not sign two different beacon blocks for the same slot, the validator is safe against proposer slashings.*
 
 Specifically, when signing a `BeaconBlock`, a validator should perform the following steps in the following order:
 
-1. Save a record to hard disk that a beacon block has been signed for the `epoch=compute_epoch_at_slot(block.slot)`.
+1. Save a record to hard disk that a beacon block has been signed for the `slot=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.

From 047936eb2de42308a00280394a4ee6fbec719164 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 Feb 2020 18:53:26 -0700
Subject: [PATCH 06/33] Add no repeat attestation condition for
 committee_index_beacon_attestation gossip channel

---
 specs/phase0/p2p-interface.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index d47bac734..1fadd153a 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -273,9 +273,11 @@ Attestation subnets are used to propagate unaggregated attestations to subsectio
 
 - `committee_index{subnet_id}_beacon_attestation` - These topics are used to propagate unaggregated attestations to the subnet `subnet_id` (typically beacon and persistent committees) to be aggregated before being gossiped to `beacon_aggregate_and_proof`. The following validations MUST pass before forwarding the `attestation` on the subnet.
     - The attestation's committee index (`attestation.data.index`) is for the correct subnet.
-    - The attestation is unaggregated -- that is, it has exactly one participating validator (`len([bit for bit in attestation.aggregation_bits if bit == 0b1]) == 1`).
-    - The block being voted for (`attestation.data.beacon_block_root`) passes validation.
+    - The attestation is the first attestation received for the participating validator for the slot `attestation.data.slot`
     - `attestation.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (within a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `attestation.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= attestation.data.slot`.
+    - The attestation is unaggregated -- that is, it has exactly one participating validator (`len([bit for bit in attestation.aggregation_bits if bit == 0b1]) == 1`).
+    - This is the first attestation for the participating validator at this slot.
+    - The block being voted for (`attestation.data.beacon_block_root`) passes validation.
     - The signature of `attestation` is valid.
 
 #### Interop

From 8da7a84eb7dc1f1cbf0bbdf32758a238390abfce Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 Feb 2020 19:13:50 -0700
Subject: [PATCH 07/33] create SignedAggregateAndProof to prevent DoS attacks

---
 specs/phase0/p2p-interface.md | 38 ++++++++++++++++++-----------------
 specs/phase0/validator.md     | 14 +++++++++++--
 2 files changed, 32 insertions(+), 20 deletions(-)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index 1fadd153a..38adfb316 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -229,15 +229,15 @@ where `base64` is the [URL-safe base64 alphabet](https://tools.ietf.org/html/rfc
 
 The payload is carried in the `data` field of a gossipsub message, and varies depending on the topic:
 
-| Topic                                          | Message Type         |
-|------------------------------------------------|----------------------|
-| beacon_block                                   | SignedBeaconBlock    |
-| beacon_aggregate_and_proof                     | AggregateAndProof    |
-| beacon_attestation\*                           | Attestation          |
-| committee_index{subnet_id}\_beacon_attestation | Attestation          |
-| voluntary_exit                                 | SignedVoluntaryExit  |
-| proposer_slashing                              | ProposerSlashing     |
-| attester_slashing                              | AttesterSlashing     |
+| Topic                                          | Message Type            |
+|------------------------------------------------|-------------------------|
+| beacon_block                                   | SignedBeaconBlock       |
+| beacon_aggregate_and_proof                     | SignedAggregateAndProof |
+| beacon_attestation\*                           | Attestation             |
+| committee_index{subnet_id}\_beacon_attestation | Attestation             |
+| voluntary_exit                                 | SignedVoluntaryExit     |
+| proposer_slashing                              | ProposerSlashing        |
+| attester_slashing                              | AttesterSlashing        |
 
 Clients MUST reject (fail validation) messages containing an incorrect type, or invalid payload.
 
@@ -250,16 +250,18 @@ When processing incoming gossip, clients MAY descore or disconnect peers who fai
 There are two primary global topics used to propagate beacon blocks and aggregate attestations to all nodes on the network. Their `TopicName`s are:
 
 - `beacon_block` - This topic is used solely for propagating new signed beacon blocks to all nodes on the networks. Signed blocks are sent in their entirety. The following validations MUST pass before forwarding the `signed_beacon_block` on the network
-    - The proposer signature, `signed_beacon_block.signature` is valid.
+    - The proposer signature, `signed_beacon_block.signature`, is valid.
     - The block is not from a future slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. validate that `signed_beacon_block.message.slot <= current_slot` (a client MAY queue future blocks for processing at the appropriate slot).
-- `beacon_aggregate_and_proof` - This topic is used to propagate aggregated attestations (as `AggregateAndProof`s) to subscribing nodes (typically validators) to be included in future blocks. The following validations MUST pass before forwarding the `aggregate_and_proof` on the network.
-    - The aggregate attestation defined by `hash_tree_root(aggregate_and_proof.aggregate)` has _not_ already been seen (via aggregate gossip, within a block, or through the creation of an equivalent aggregate locally).
-    - The block being voted for (`aggregate_and_proof.aggregate.data.beacon_block_root`) passes validation.
-    - `aggregate_and_proof.aggregate.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `aggregate_and_proof.aggregate.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= aggregate_and_proof.aggregate.data.slot`.
-    - The validator index is within the aggregate's committee -- i.e. `aggregate_and_proof.aggregator_index in get_attesting_indices(state, aggregate_and_proof.aggregate.data, aggregate_and_proof.aggregate.aggregation_bits)`.
-    - `aggregate_and_proof.selection_proof` selects the validator as an aggregator for the slot -- i.e. `is_aggregator(state, aggregate_and_proof.aggregate.data.slot, aggregate_and_proof.aggregate.data.index, aggregate_and_proof.selection_proof)` returns `True`.
-    - The `aggregate_and_proof.selection_proof` is a valid signature of the `aggregate_and_proof.aggregate.data.slot` by the validator with index `aggregate_and_proof.aggregator_index`.
-    - The signature of `aggregate_and_proof.aggregate` is valid.
+- `beacon_aggregate_and_proof` - This topic is used to propagate aggregated attestations (as `SignedAggregateAndProof`s) to subscribing nodes (typically validators) to be included in future blocks. The following validations MUST pass before forwarding the `signed_aggregate_and_proof` on the network. (We define the following for convenience -- `aggregate_and_proof = signed_aggregate_and_proof.message` and `aggregate = aggregate_and_proof.aggregate`)
+    - The aggregate attestation defined by `hash_tree_root(aggregate)` has _not_ already been seen (via aggregate gossip, within a block, or through the creation of an equivalent aggregate locally).
+    - The block being voted for (`aggregate.data.beacon_block_root`) passes validation.
+    - `aggregate.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `aggregate.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= aggregate.data.slot`.
+    - The validator index is within the aggregate's committee -- i.e. `aggregate_and_proof.aggregator_index in get_attesting_indices(state, aggregate.data, aggregate.aggregation_bits)`.
+    - `aggregate_and_proof.selection_proof` selects the validator as an aggregator for the slot -- i.e. `is_aggregator(state, aggregate.data.slot, aggregate.data.index, aggregate_and_proof.selection_proof)` returns `True`.
+    - The `signed_aggregate_and_proof` is the first aggregate received for the aggregator for the slot `aggregate.data.slot`
+    - The `aggregate_and_proof.selection_proof` is a valid signature of the `aggregate.data.slot` by the validator with index `aggregate_and_proof.aggregator_index`.
+    - The aggregator signature, `signed_aggregate_and_proof.signature`, is valid.
+    - The signature of `aggregate` is valid.
 
 Additional global topics are used to propagate lower frequency validator messages. Their `TopicName`s are:
 
diff --git a/specs/phase0/validator.md b/specs/phase0/validator.md
index 901fb562d..8996428cc 100644
--- a/specs/phase0/validator.md
+++ b/specs/phase0/validator.md
@@ -461,9 +461,11 @@ def get_aggregate_signature(attestations: Sequence[Attestation]) -> BLSSignature
 
 #### Broadcast aggregate
 
-If the validator is selected to aggregate (`is_aggregator`), then they broadcast their best aggregate to the global aggregate channel (`beacon_aggregate_and_proof`) two-thirds of the way through the `slot`-that is, `SECONDS_PER_SLOT * 2 / 3` seconds after the start of `slot`.
+If the validator is selected to aggregate (`is_aggregator`), then they broadcast their best aggregate as a `SignedAggregateAndProof` to the global aggregate channel (`beacon_aggregate_and_proof`) two-thirds of the way through the `slot`-that is, `SECONDS_PER_SLOT * 2 / 3` seconds after the start of `slot`.
 
-Aggregate attestations are broadcast as `AggregateAndProof` objects to prove to the gossip channel that the validator has been selected as an aggregator.
+Selection proofs are provided in `AggregateAndProof` to prove to the gossip channel that the validator has been selected as an aggregator.
+
+`AggregateAndProof` messages are signed and broadcast inside of `SignedAggregateAndProof` objects to prevent a class of DoS attacks and message forgeries.
 
 ##### `AggregateAndProof`
 
@@ -479,6 +481,14 @@ Where
 * `aggregate` is the `aggregate_attestation` constructed in the previous section.
 * `selection_proof` is the signature of the slot (`get_slot_signature()`).
 
+##### `SignedAggregateAndProof`
+
+```python
+class SignedAggregateAndProof(Container):
+    message: AggregateAndProof
+    signature: BLSSignature
+```
+
 ## Phase 0 attestation subnet stability
 
 Because Phase 0 does not have shards and thus does not have Shard Committees, there is no stable backbone to the attestation subnets (`committee_index{subnet_id}_beacon_attestation`). To provide this stability, each validator must:

From 343168908cab7700cd28318536dc2d608500d44c Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 Feb 2020 19:28:37 -0700
Subject: [PATCH 08/33] prevent multiple beacon blocks from same proposer in a
 given slot

---
 specs/phase0/p2p-interface.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index 38adfb316..9979cbb14 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -250,6 +250,7 @@ When processing incoming gossip, clients MAY descore or disconnect peers who fai
 There are two primary global topics used to propagate beacon blocks and aggregate attestations to all nodes on the network. Their `TopicName`s are:
 
 - `beacon_block` - This topic is used solely for propagating new signed beacon blocks to all nodes on the networks. Signed blocks are sent in their entirety. The following validations MUST pass before forwarding the `signed_beacon_block` on the network
+    - The block is the first block received for the proposer for the slot, `signed_beacon_block.message.slot`.
     - The proposer signature, `signed_beacon_block.signature`, is valid.
     - The block is not from a future slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. validate that `signed_beacon_block.message.slot <= current_slot` (a client MAY queue future blocks for processing at the appropriate slot).
 - `beacon_aggregate_and_proof` - This topic is used to propagate aggregated attestations (as `SignedAggregateAndProof`s) to subscribing nodes (typically validators) to be included in future blocks. The following validations MUST pass before forwarding the `signed_aggregate_and_proof` on the network. (We define the following for convenience -- `aggregate_and_proof = signed_aggregate_and_proof.message` and `aggregate = aggregate_and_proof.aggregate`)
@@ -258,7 +259,7 @@ There are two primary global topics used to propagate beacon blocks and aggregat
     - `aggregate.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `aggregate.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= aggregate.data.slot`.
     - The validator index is within the aggregate's committee -- i.e. `aggregate_and_proof.aggregator_index in get_attesting_indices(state, aggregate.data, aggregate.aggregation_bits)`.
     - `aggregate_and_proof.selection_proof` selects the validator as an aggregator for the slot -- i.e. `is_aggregator(state, aggregate.data.slot, aggregate.data.index, aggregate_and_proof.selection_proof)` returns `True`.
-    - The `signed_aggregate_and_proof` is the first aggregate received for the aggregator for the slot `aggregate.data.slot`
+    - The `signed_aggregate_and_proof` is the first aggregate received for the aggregator for the slot, `aggregate.data.slot`
     - The `aggregate_and_proof.selection_proof` is a valid signature of the `aggregate.data.slot` by the validator with index `aggregate_and_proof.aggregator_index`.
     - The aggregator signature, `signed_aggregate_and_proof.signature`, is valid.
     - The signature of `aggregate` is valid.
@@ -275,7 +276,7 @@ Attestation subnets are used to propagate unaggregated attestations to subsectio
 
 - `committee_index{subnet_id}_beacon_attestation` - These topics are used to propagate unaggregated attestations to the subnet `subnet_id` (typically beacon and persistent committees) to be aggregated before being gossiped to `beacon_aggregate_and_proof`. The following validations MUST pass before forwarding the `attestation` on the subnet.
     - The attestation's committee index (`attestation.data.index`) is for the correct subnet.
-    - The attestation is the first attestation received for the participating validator for the slot `attestation.data.slot`
+    - The attestation is the first attestation received for the participating validator for the slot, `attestation.data.slot`
     - `attestation.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (within a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `attestation.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= attestation.data.slot`.
     - The attestation is unaggregated -- that is, it has exactly one participating validator (`len([bit for bit in attestation.aggregation_bits if bit == 0b1]) == 1`).
     - This is the first attestation for the participating validator at this slot.

From fd633d246781a27e74d354476e29c0d09ec49fc8 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 Feb 2020 19:35:36 -0700
Subject: [PATCH 09/33] add clarifying note to signedaggregateandproof in
 vaidator guide and fix tocs

---
 specs/phase0/validator.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/specs/phase0/validator.md b/specs/phase0/validator.md
index 8996428cc..528bcf751 100644
--- a/specs/phase0/validator.md
+++ b/specs/phase0/validator.md
@@ -59,6 +59,7 @@
       - [Aggregate signature](#aggregate-signature-1)
     - [Broadcast aggregate](#broadcast-aggregate)
       - [`AggregateAndProof`](#aggregateandproof)
+      - [`SignedAggregateAndProof`](#signedaggregateandproof)
 - [Phase 0 attestation subnet stability](#phase-0-attestation-subnet-stability)
 - [How to avoid slashing](#how-to-avoid-slashing)
   - [Proposer slashing](#proposer-slashing)
@@ -465,7 +466,7 @@ If the validator is selected to aggregate (`is_aggregator`), then they broadcast
 
 Selection proofs are provided in `AggregateAndProof` to prove to the gossip channel that the validator has been selected as an aggregator.
 
-`AggregateAndProof` messages are signed and broadcast inside of `SignedAggregateAndProof` objects to prevent a class of DoS attacks and message forgeries.
+`AggregateAndProof` messages are signed by the aggregator and broadcast inside of `SignedAggregateAndProof` objects to prevent a class of DoS attacks and message forgeries.
 
 ##### `AggregateAndProof`
 

From 5ee1f9b54543210afffbddb1320513649934be50 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 Feb 2020 21:35:39 -0700
Subject: [PATCH 10/33] fix up some p2p validation conditions based on PR
 feedback

---
 specs/phase0/p2p-interface.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index 9979cbb14..c60ba560c 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -276,10 +276,9 @@ Attestation subnets are used to propagate unaggregated attestations to subsectio
 
 - `committee_index{subnet_id}_beacon_attestation` - These topics are used to propagate unaggregated attestations to the subnet `subnet_id` (typically beacon and persistent committees) to be aggregated before being gossiped to `beacon_aggregate_and_proof`. The following validations MUST pass before forwarding the `attestation` on the subnet.
     - The attestation's committee index (`attestation.data.index`) is for the correct subnet.
-    - The attestation is the first attestation received for the participating validator for the slot, `attestation.data.slot`
     - `attestation.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (within a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `attestation.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= attestation.data.slot`.
     - The attestation is unaggregated -- that is, it has exactly one participating validator (`len([bit for bit in attestation.aggregation_bits if bit == 0b1]) == 1`).
-    - This is the first attestation for the participating validator at this slot.
+    - The attestation is the first attestation received for the participating validator for the slot, `attestation.data.slot`.
     - The block being voted for (`attestation.data.beacon_block_root`) passes validation.
     - The signature of `attestation` is valid.
 

From dde69cb8e2c7182accdab3d19434b66c2df80156 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 11 Feb 2020 15:45:51 -0700
Subject: [PATCH 11/33] add explicit instrucutions for construction of
 signed_aggregate_and_proof. add DOMAIN_SELECTION_PROOF and
 DOMAIN_AGGREGATE_AND_PROOF

---
 configs/mainnet.yaml         |  2 ++
 configs/minimal.yaml         |  2 ++
 specs/phase0/beacon-chain.md | 13 ++++++++-----
 specs/phase0/validator.md    | 28 +++++++++++++++++++++++++++-
 4 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/configs/mainnet.yaml b/configs/mainnet.yaml
index 6eb5641d0..74f062d9b 100644
--- a/configs/mainnet.yaml
+++ b/configs/mainnet.yaml
@@ -143,6 +143,8 @@ DOMAIN_BEACON_ATTESTER: 0x01000000
 DOMAIN_RANDAO: 0x02000000
 DOMAIN_DEPOSIT: 0x03000000
 DOMAIN_VOLUNTARY_EXIT: 0x04000000
+DOMAIN_SELECTION_PROOF: 0x05000000
+DOMAIN_AGGREGATE_AND_PROOF: 0x06000000
 # Phase 1
 DOMAIN_SHARD_PROPOSAL: 0x80000000
 DOMAIN_SHARD_COMMITTEE: 0x81000000
diff --git a/configs/minimal.yaml b/configs/minimal.yaml
index 03ffa90e3..42c63e301 100644
--- a/configs/minimal.yaml
+++ b/configs/minimal.yaml
@@ -142,6 +142,8 @@ DOMAIN_BEACON_ATTESTER: 0x01000000
 DOMAIN_RANDAO: 0x02000000
 DOMAIN_DEPOSIT: 0x03000000
 DOMAIN_VOLUNTARY_EXIT: 0x04000000
+DOMAIN_SELECTION_PROOF: 0x05000000
+DOMAIN_AGGREGATE_AND_PROOF: 0x06000000
 # Phase 1
 DOMAIN_SHARD_PROPOSAL: 0x80000000
 DOMAIN_SHARD_COMMITTEE: 0x81000000
diff --git a/specs/phase0/beacon-chain.md b/specs/phase0/beacon-chain.md
index 96ea351c8..2ab51079d 100644
--- a/specs/phase0/beacon-chain.md
+++ b/specs/phase0/beacon-chain.md
@@ -253,11 +253,14 @@ The following values are (non-configurable) constants used throughout the specif
 
 | Name | Value |
 | - | - |
-| `DOMAIN_BEACON_PROPOSER` | `DomainType('0x00000000')` |
-| `DOMAIN_BEACON_ATTESTER` | `DomainType('0x01000000')` |
-| `DOMAIN_RANDAO` | `DomainType('0x02000000')` |
-| `DOMAIN_DEPOSIT` | `DomainType('0x03000000')` |
-| `DOMAIN_VOLUNTARY_EXIT` | `DomainType('0x04000000')` |
+| `DOMAIN_BEACON_PROPOSER`     | `DomainType('0x00000000')` |
+| `DOMAIN_BEACON_ATTESTER`     | `DomainType('0x01000000')` |
+| `DOMAIN_RANDAO`              | `DomainType('0x02000000')` |
+| `DOMAIN_DEPOSIT`             | `DomainType('0x03000000')` |
+| `DOMAIN_VOLUNTARY_EXIT`      | `DomainType('0x04000000')` |
+| `DOMAIN_SELECTION_PROOF`     | `DomainType('0x05000000')` |
+| `DOMAIN_AGGREGATE_AND_PROOF` | `DomainType('0x06000000')` |
+
 
 ## Containers
 
diff --git a/specs/phase0/validator.md b/specs/phase0/validator.md
index 528bcf751..ad9ef9f37 100644
--- a/specs/phase0/validator.md
+++ b/specs/phase0/validator.md
@@ -424,7 +424,7 @@ A validator is selected to aggregate based upon the return value of `is_aggregat
 
 ```python
 def get_slot_signature(state: BeaconState, slot: Slot, privkey: int) -> BLSSignature:
-    domain = get_domain(state, DOMAIN_BEACON_ATTESTER, compute_epoch_at_slot(slot))
+    domain = get_domain(state, DOMAIN_SELECTION_PROOF, compute_epoch_at_slot(slot))
     signing_root = compute_signing_root(slot, domain)
     return bls.Sign(privkey, signing_root)
 ```
@@ -468,6 +468,32 @@ Selection proofs are provided in `AggregateAndProof` to prove to the gossip chan
 
 `AggregateAndProof` messages are signed by the aggregator and broadcast inside of `SignedAggregateAndProof` objects to prevent a class of DoS attacks and message forgeries.
 
+First, `aggregate_and_proof = get_aggregate_and_proof(state, aggregate_attestation, validator_index, privkey)` is contructed.
+
+```python
+def get_aggregate_and_proof(state: BeaconState,
+                            aggregate: Attestation,
+                            aggregator_index: ValidatorIndex,
+                            privkey: int) -> AggregateAndProof:
+    return AggregateAndProof(
+        aggregator_index=aggregator_index,
+        aggregate=aggregate,
+        selection_proof=get_slot_signature(state, aggregate.data.slot, privkey),
+    )
+```
+
+Then `signed_aggregate_and_proof = SignedAggregateAndProof(message=aggregate_and_proof, signature=signature)` is constructed and broadast. Where `signature` is obtained from:
+
+```python
+def get_aggregate_and_proof_signature(state: BeaconState,
+                                      aggregate_and_proof: AggregateAndProof,
+                                      privkey: int) -> BLSSignature:
+    aggregate = aggregate_and_proof.aggregate
+    domain = get_domain(state, DOMAIN_AGGREGATE_AND_PROOF, compute_epoch_at_slot(aggregate.data.slot))
+    signing_root = compute_signing_root(aggregate_and_proof, domain)
+    return bls.Sign(privkey, signing_root)
+```
+
 ##### `AggregateAndProof`
 
 ```python

From d2e08c0cdf7d56cebf7f64180586bd19cb54b61a Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 11 Feb 2020 15:46:30 -0700
Subject: [PATCH 12/33] subnet validation PR feedback

---
 specs/phase0/p2p-interface.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index c60ba560c..c0dd88643 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -257,9 +257,9 @@ There are two primary global topics used to propagate beacon blocks and aggregat
     - The aggregate attestation defined by `hash_tree_root(aggregate)` has _not_ already been seen (via aggregate gossip, within a block, or through the creation of an equivalent aggregate locally).
     - The block being voted for (`aggregate.data.beacon_block_root`) passes validation.
     - `aggregate.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `aggregate.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= aggregate.data.slot`.
-    - The validator index is within the aggregate's committee -- i.e. `aggregate_and_proof.aggregator_index in get_attesting_indices(state, aggregate.data, aggregate.aggregation_bits)`.
+    - The aggregator's validator index is within the aggregate's committee -- i.e. `aggregate_and_proof.aggregator_index in get_attesting_indices(state, aggregate.data, aggregate.aggregation_bits)`.
     - `aggregate_and_proof.selection_proof` selects the validator as an aggregator for the slot -- i.e. `is_aggregator(state, aggregate.data.slot, aggregate.data.index, aggregate_and_proof.selection_proof)` returns `True`.
-    - The `signed_aggregate_and_proof` is the first aggregate received for the aggregator for the slot, `aggregate.data.slot`
+    - The `aggregate` is the first aggregate received for the aggregator with index `aggregate_and_proof.aggregator_index` for the slot `aggregate.data.slot`.
     - The `aggregate_and_proof.selection_proof` is a valid signature of the `aggregate.data.slot` by the validator with index `aggregate_and_proof.aggregator_index`.
     - The aggregator signature, `signed_aggregate_and_proof.signature`, is valid.
     - The signature of `aggregate` is valid.

From f7181adece04e9440e128d37fe3d11c38d7d26ff Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 11 Feb 2020 15:49:45 -0700
Subject: [PATCH 13/33] reverse params in get_aggregate_and_proof to match ssz
 type

---
 specs/phase0/validator.md | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/specs/phase0/validator.md b/specs/phase0/validator.md
index ad9ef9f37..0bde81e60 100644
--- a/specs/phase0/validator.md
+++ b/specs/phase0/validator.md
@@ -468,12 +468,12 @@ Selection proofs are provided in `AggregateAndProof` to prove to the gossip chan
 
 `AggregateAndProof` messages are signed by the aggregator and broadcast inside of `SignedAggregateAndProof` objects to prevent a class of DoS attacks and message forgeries.
 
-First, `aggregate_and_proof = get_aggregate_and_proof(state, aggregate_attestation, validator_index, privkey)` is contructed.
+First, `aggregate_and_proof = get_aggregate_and_proof(state, validator_index, aggregate_attestation, privkey)` is constructed.
 
 ```python
 def get_aggregate_and_proof(state: BeaconState,
-                            aggregate: Attestation,
                             aggregator_index: ValidatorIndex,
+                            aggregate: Attestation,
                             privkey: int) -> AggregateAndProof:
     return AggregateAndProof(
         aggregator_index=aggregator_index,
@@ -503,11 +503,6 @@ class AggregateAndProof(Container):
     selection_proof: BLSSignature
 ```
 
-Where
-* `aggregator_index` is the validator's `ValidatorIndex`.
-* `aggregate` is the `aggregate_attestation` constructed in the previous section.
-* `selection_proof` is the signature of the slot (`get_slot_signature()`).
-
 ##### `SignedAggregateAndProof`
 
 ```python

From 581257e269275ce17b8c4a84d77532de5e93081c Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 12 Feb 2020 11:59:00 -0700
Subject: [PATCH 14/33] reorder gossip conditions to put cheap checks before
 signature verifications

---
 specs/phase0/p2p-interface.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index c0dd88643..f5a82bad4 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -250,16 +250,16 @@ When processing incoming gossip, clients MAY descore or disconnect peers who fai
 There are two primary global topics used to propagate beacon blocks and aggregate attestations to all nodes on the network. Their `TopicName`s are:
 
 - `beacon_block` - This topic is used solely for propagating new signed beacon blocks to all nodes on the networks. Signed blocks are sent in their entirety. The following validations MUST pass before forwarding the `signed_beacon_block` on the network
+    - The block is not from a future slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. validate that `signed_beacon_block.message.slot <= current_slot` (a client MAY queue future blocks for processing at the appropriate slot).
     - The block is the first block received for the proposer for the slot, `signed_beacon_block.message.slot`.
     - The proposer signature, `signed_beacon_block.signature`, is valid.
-    - The block is not from a future slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. validate that `signed_beacon_block.message.slot <= current_slot` (a client MAY queue future blocks for processing at the appropriate slot).
 - `beacon_aggregate_and_proof` - This topic is used to propagate aggregated attestations (as `SignedAggregateAndProof`s) to subscribing nodes (typically validators) to be included in future blocks. The following validations MUST pass before forwarding the `signed_aggregate_and_proof` on the network. (We define the following for convenience -- `aggregate_and_proof = signed_aggregate_and_proof.message` and `aggregate = aggregate_and_proof.aggregate`)
+    - `aggregate.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `aggregate.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= aggregate.data.slot` (a client MAY queue future aggregates for processing at the appropriate slot).
     - The aggregate attestation defined by `hash_tree_root(aggregate)` has _not_ already been seen (via aggregate gossip, within a block, or through the creation of an equivalent aggregate locally).
-    - The block being voted for (`aggregate.data.beacon_block_root`) passes validation.
-    - `aggregate.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `aggregate.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= aggregate.data.slot`.
-    - The aggregator's validator index is within the aggregate's committee -- i.e. `aggregate_and_proof.aggregator_index in get_attesting_indices(state, aggregate.data, aggregate.aggregation_bits)`.
-    - `aggregate_and_proof.selection_proof` selects the validator as an aggregator for the slot -- i.e. `is_aggregator(state, aggregate.data.slot, aggregate.data.index, aggregate_and_proof.selection_proof)` returns `True`.
     - The `aggregate` is the first aggregate received for the aggregator with index `aggregate_and_proof.aggregator_index` for the slot `aggregate.data.slot`.
+    - The block being voted for (`aggregate.data.beacon_block_root`) passes validation.
+    - `aggregate_and_proof.selection_proof` selects the validator as an aggregator for the slot -- i.e. `is_aggregator(state, aggregate.data.slot, aggregate.data.index, aggregate_and_proof.selection_proof)` returns `True`.
+    - The aggregator's validator index is within the aggregate's committee -- i.e. `aggregate_and_proof.aggregator_index in get_attesting_indices(state, aggregate.data, aggregate.aggregation_bits)`.
     - The `aggregate_and_proof.selection_proof` is a valid signature of the `aggregate.data.slot` by the validator with index `aggregate_and_proof.aggregator_index`.
     - The aggregator signature, `signed_aggregate_and_proof.signature`, is valid.
     - The signature of `aggregate` is valid.
@@ -276,7 +276,7 @@ Attestation subnets are used to propagate unaggregated attestations to subsectio
 
 - `committee_index{subnet_id}_beacon_attestation` - These topics are used to propagate unaggregated attestations to the subnet `subnet_id` (typically beacon and persistent committees) to be aggregated before being gossiped to `beacon_aggregate_and_proof`. The following validations MUST pass before forwarding the `attestation` on the subnet.
     - The attestation's committee index (`attestation.data.index`) is for the correct subnet.
-    - `attestation.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (within a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `attestation.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= attestation.data.slot`.
+    - `attestation.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (within a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `attestation.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= attestation.data.slot` (a client MAY queue future attestations for processing at the appropriate slot).
     - The attestation is unaggregated -- that is, it has exactly one participating validator (`len([bit for bit in attestation.aggregation_bits if bit == 0b1]) == 1`).
     - The attestation is the first attestation received for the participating validator for the slot, `attestation.data.slot`.
     - The block being voted for (`attestation.data.beacon_block_root`) passes validation.

From 3404f1e07805ec98038e2849e57c05d7f06b3de8 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 12 Feb 2020 12:07:57 -0700
Subject: [PATCH 15/33] add lower bound condition on block gossip

---
 specs/phase0/p2p-interface.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index f5a82bad4..81536a314 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -251,6 +251,7 @@ There are two primary global topics used to propagate beacon blocks and aggregat
 
 - `beacon_block` - This topic is used solely for propagating new signed beacon blocks to all nodes on the networks. Signed blocks are sent in their entirety. The following validations MUST pass before forwarding the `signed_beacon_block` on the network
     - The block is not from a future slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. validate that `signed_beacon_block.message.slot <= current_slot` (a client MAY queue future blocks for processing at the appropriate slot).
+    - The block is not from later than the latest finalized slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. validate that `signed_beacon_block.message.slot > compute_start_slot_at_epoch(state.finalized_checkpoint.epoch)` (a client MAY choose to validate and store such blocks for additional purposes -- e.g. slashing detection, archive nodes, etc).
     - The block is the first block received for the proposer for the slot, `signed_beacon_block.message.slot`.
     - The proposer signature, `signed_beacon_block.signature`, is valid.
 - `beacon_aggregate_and_proof` - This topic is used to propagate aggregated attestations (as `SignedAggregateAndProof`s) to subscribing nodes (typically validators) to be included in future blocks. The following validations MUST pass before forwarding the `signed_aggregate_and_proof` on the network. (We define the following for convenience -- `aggregate_and_proof = signed_aggregate_and_proof.message` and `aggregate = aggregate_and_proof.aggregate`)

From 7329cc09337e1b8cdff24c272824186cc129631d Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 12 Feb 2020 15:46:48 -0700
Subject: [PATCH 16/33] pr feedback

Co-Authored-By: Diederik Loerakker <proto@protolambda.com>
---
 specs/phase0/p2p-interface.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index 81536a314..d7fbbf8a7 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -251,7 +251,7 @@ There are two primary global topics used to propagate beacon blocks and aggregat
 
 - `beacon_block` - This topic is used solely for propagating new signed beacon blocks to all nodes on the networks. Signed blocks are sent in their entirety. The following validations MUST pass before forwarding the `signed_beacon_block` on the network
     - The block is not from a future slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. validate that `signed_beacon_block.message.slot <= current_slot` (a client MAY queue future blocks for processing at the appropriate slot).
-    - The block is not from later than the latest finalized slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. validate that `signed_beacon_block.message.slot > compute_start_slot_at_epoch(state.finalized_checkpoint.epoch)` (a client MAY choose to validate and store such blocks for additional purposes -- e.g. slashing detection, archive nodes, etc).
+    - The block is from a slot greater than the latest finalized slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. validate that `signed_beacon_block.message.slot > compute_start_slot_at_epoch(state.finalized_checkpoint.epoch)` (a client MAY choose to validate and store such blocks for additional purposes -- e.g. slashing detection, archive nodes, etc).
     - The block is the first block received for the proposer for the slot, `signed_beacon_block.message.slot`.
     - The proposer signature, `signed_beacon_block.signature`, is valid.
 - `beacon_aggregate_and_proof` - This topic is used to propagate aggregated attestations (as `SignedAggregateAndProof`s) to subscribing nodes (typically validators) to be included in future blocks. The following validations MUST pass before forwarding the `signed_aggregate_and_proof` on the network. (We define the following for convenience -- `aggregate_and_proof = signed_aggregate_and_proof.message` and `aggregate = aggregate_and_proof.aggregate`)

From f671b86776c52cea8d530c036583bf9fa15a1df0 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 12 Feb 2020 15:48:49 -0700
Subject: [PATCH 17/33] add DoS prevention validation conditions to
 voluntary_exit, proposer_slashing, and attester_slashing gossipsub channels

---
 specs/phase0/p2p-interface.md | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index d7fbbf8a7..54db92539 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -252,12 +252,12 @@ There are two primary global topics used to propagate beacon blocks and aggregat
 - `beacon_block` - This topic is used solely for propagating new signed beacon blocks to all nodes on the networks. Signed blocks are sent in their entirety. The following validations MUST pass before forwarding the `signed_beacon_block` on the network
     - The block is not from a future slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. validate that `signed_beacon_block.message.slot <= current_slot` (a client MAY queue future blocks for processing at the appropriate slot).
     - The block is from a slot greater than the latest finalized slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. validate that `signed_beacon_block.message.slot > compute_start_slot_at_epoch(state.finalized_checkpoint.epoch)` (a client MAY choose to validate and store such blocks for additional purposes -- e.g. slashing detection, archive nodes, etc).
-    - The block is the first block received for the proposer for the slot, `signed_beacon_block.message.slot`.
+    - The block is the first block with valid signature received for the proposer for the slot, `signed_beacon_block.message.slot`.
     - The proposer signature, `signed_beacon_block.signature`, is valid.
 - `beacon_aggregate_and_proof` - This topic is used to propagate aggregated attestations (as `SignedAggregateAndProof`s) to subscribing nodes (typically validators) to be included in future blocks. The following validations MUST pass before forwarding the `signed_aggregate_and_proof` on the network. (We define the following for convenience -- `aggregate_and_proof = signed_aggregate_and_proof.message` and `aggregate = aggregate_and_proof.aggregate`)
     - `aggregate.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `aggregate.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= aggregate.data.slot` (a client MAY queue future aggregates for processing at the appropriate slot).
     - The aggregate attestation defined by `hash_tree_root(aggregate)` has _not_ already been seen (via aggregate gossip, within a block, or through the creation of an equivalent aggregate locally).
-    - The `aggregate` is the first aggregate received for the aggregator with index `aggregate_and_proof.aggregator_index` for the slot `aggregate.data.slot`.
+    - The `aggregate` is the first valid aggregate received for the aggregator with index `aggregate_and_proof.aggregator_index` for the slot `aggregate.data.slot`.
     - The block being voted for (`aggregate.data.beacon_block_root`) passes validation.
     - `aggregate_and_proof.selection_proof` selects the validator as an aggregator for the slot -- i.e. `is_aggregator(state, aggregate.data.slot, aggregate.data.index, aggregate_and_proof.selection_proof)` returns `True`.
     - The aggregator's validator index is within the aggregate's committee -- i.e. `aggregate_and_proof.aggregator_index in get_attesting_indices(state, aggregate.data, aggregate.aggregation_bits)`.
@@ -267,9 +267,16 @@ There are two primary global topics used to propagate beacon blocks and aggregat
 
 Additional global topics are used to propagate lower frequency validator messages. Their `TopicName`s are:
 
-- `voluntary_exit` - This topic is used solely for propagating signed voluntary validator exits to proposers on the network. Signed voluntary exits are sent in their entirety. Clients who receive a signed voluntary exit on this topic MUST validate the conditions within `process_voluntary_exit` before forwarding it across the network.
-- `proposer_slashing` - This topic is used solely for propagating proposer slashings to proposers on the network. Proposer slashings are sent in their entirety. Clients who receive a proposer slashing on this topic MUST validate the conditions within `process_proposer_slashing` before forwarding it across the network.
+- `voluntary_exit` - This topic is used solely for propagating signed voluntary validator exits to proposers on the network. Signed voluntary exits are sent in their entirety. The following validations MUST pass before forwarding the `signed_voluntary_exit` on to the network
+    - The voluntary exit is the first valid voluntary exit received for the validator with index `signed_voluntary_exit.message.validator_index`.
+    - All of the conditions within `process_voluntary_exit` pass validation.
+- `proposer_slashing` - This topic is used solely for propagating proposer slashings to proposers on the network. Proposer slashings are sent in their entirety. The following validations MUST pass before forwarding the `proposer_slashing` on to the network
+    - The proposer slashing is the first valid proposer slashing received for the proposer with index `proposer_slashing.index`.
+    - All of the conditions within `process_proposer_slashing` pass validation.
 - `attester_slashing` - This topic is used solely for propagating attester slashings to proposers on the network. Attester slashings are sent in their entirety. Clients who receive an attester slashing on this topic MUST validate the conditions within `process_attester_slashing` before forwarding it across the network.
+    - At least one index in the intersection of the attesting indices of each attestation has not yet been seen in any prior `attester_slashing` (i.e. `any((set(attestation_1.attesting_indices).intersection(attestation_2.attesting_indices)).difference(prior_seen_attester_slashed_indices))`).
+    - All of the conditions within `process_attester_slashing` pass validation.
+
 
 #### Attestation subnets
 
@@ -279,7 +286,7 @@ Attestation subnets are used to propagate unaggregated attestations to subsectio
     - The attestation's committee index (`attestation.data.index`) is for the correct subnet.
     - `attestation.data.slot` is within the last `ATTESTATION_PROPAGATION_SLOT_RANGE` slots (within a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) -- i.e. `attestation.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= attestation.data.slot` (a client MAY queue future attestations for processing at the appropriate slot).
     - The attestation is unaggregated -- that is, it has exactly one participating validator (`len([bit for bit in attestation.aggregation_bits if bit == 0b1]) == 1`).
-    - The attestation is the first attestation received for the participating validator for the slot, `attestation.data.slot`.
+    - The attestation is the first valid attestation received for the participating validator for the slot, `attestation.data.slot`.
     - The block being voted for (`attestation.data.beacon_block_root`) passes validation.
     - The signature of `attestation` is valid.
 

From 3bb8e0d962b83823e24c395c6ebbe1c858559a73 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Thu, 13 Feb 2020 11:17:19 -0700
Subject: [PATCH 18/33] cleanup attester slashing conditon code snippet

Co-Authored-By: Diederik Loerakker <proto@protolambda.com>
---
 specs/phase0/p2p-interface.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index 54db92539..7ad8759d3 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -274,7 +274,7 @@ Additional global topics are used to propagate lower frequency validator message
     - The proposer slashing is the first valid proposer slashing received for the proposer with index `proposer_slashing.index`.
     - All of the conditions within `process_proposer_slashing` pass validation.
 - `attester_slashing` - This topic is used solely for propagating attester slashings to proposers on the network. Attester slashings are sent in their entirety. Clients who receive an attester slashing on this topic MUST validate the conditions within `process_attester_slashing` before forwarding it across the network.
-    - At least one index in the intersection of the attesting indices of each attestation has not yet been seen in any prior `attester_slashing` (i.e. `any((set(attestation_1.attesting_indices).intersection(attestation_2.attesting_indices)).difference(prior_seen_attester_slashed_indices))`).
+    - At least one index in the intersection of the attesting indices of each attestation has not yet been seen in any prior `attester_slashing` (i.e. `attester_slashed_indices = set(attestation_1.attesting_indices).intersection(attestation_2.attesting_indices)`, verify if `any(attester_slashed_indices.difference(prior_seen_attester_slashed_indices))`).
     - All of the conditions within `process_attester_slashing` pass validation.
 
 

From 934c037a8a9959209ff978882f5b142f619341da Mon Sep 17 00:00:00 2001
From: Ben Edgington <ben@benjaminion.xyz>
Date: Fri, 14 Feb 2020 14:29:45 +0000
Subject: [PATCH 19/33] Correct the duration of HISTORICAL_ROOTS_LIMIT

The duration of HISTORICAL_ROOTS_LIMIT is:
    SECONDS_PER_SLOT * SLOTS_PER_HISTORICAL_ROOT * HISTORICAL_ROOTS_LIMIT
which is
    12s * 2^13 * 2^24 = 1.65e12s = 52,262 years
---
 specs/phase0/beacon-chain.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/specs/phase0/beacon-chain.md b/specs/phase0/beacon-chain.md
index 2ab51079d..acf098663 100644
--- a/specs/phase0/beacon-chain.md
+++ b/specs/phase0/beacon-chain.md
@@ -224,7 +224,7 @@ The following values are (non-configurable) constants used throughout the specif
 | - | - | :-: | :-: |
 | `EPOCHS_PER_HISTORICAL_VECTOR` | `2**16` (= 65,536) | epochs | ~0.8 years |
 | `EPOCHS_PER_SLASHINGS_VECTOR` | `2**13` (= 8,192) | epochs | ~36 days |
-| `HISTORICAL_ROOTS_LIMIT` | `2**24` (= 16,777,216) | historical roots | ~26,131 years |
+| `HISTORICAL_ROOTS_LIMIT` | `2**24` (= 16,777,216) | historical roots | ~52,262 years |
 | `VALIDATOR_REGISTRY_LIMIT` | `2**40` (= 1,099,511,627,776) | validators |
 
 ### Rewards and penalties

From 09266cf6e82a56f20501021bcfbbee3172cf6f80 Mon Sep 17 00:00:00 2001
From: ethers <6937903+ethers@users.noreply.github.com>
Date: Mon, 17 Feb 2020 00:14:07 +0000
Subject: [PATCH 20/33] add Gasper paper

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 49d851197..3f58b3dc4 100644
--- a/README.md
+++ b/README.md
@@ -59,6 +59,7 @@ The following are the broad design goals for Ethereum 2.0:
 
 * [Design Rationale](https://notes.ethereum.org/s/rkhCgQteN#)
 * [Phase 0 Onboarding Document](https://notes.ethereum.org/s/Bkn3zpwxB)
+* [Gasper paper](https://github.com/ethereum/research/blob/master/papers/ffg%2Bghost/paper.pdf)
 
 
 ## For spec contributors

From ceb6633eb9ef6ad0226a9119e35b99e57a58b527 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Fri, 21 Feb 2020 21:44:54 -0600
Subject: [PATCH 21/33] working through phase 1 attestation testing

---
 configs/mainnet.yaml                          |  2 +-
 configs/minimal.yaml                          |  2 +-
 specs/phase1/beacon-chain.md                  | 19 ++--
 .../eth2spec/test/helpers/attestations.py     | 37 +++++++-
 .../test/helpers/phase1/attestations.py       | 82 ++++++++++++-----
 .../test_process_attestation.py               | 37 +-------
 .../test_process_attestation.py               | 91 +++++++------------
 7 files changed, 142 insertions(+), 128 deletions(-)

diff --git a/configs/mainnet.yaml b/configs/mainnet.yaml
index 74f062d9b..c7940bceb 100644
--- a/configs/mainnet.yaml
+++ b/configs/mainnet.yaml
@@ -179,7 +179,7 @@ MAX_SHARD_BLOCK_CHUNKS: 4
 # 3 * 2**16` (= 196,608)
 TARGET_SHARD_BLOCK_SIZE: 196608
 # Note: MAX_SHARD_BLOCKS_PER_ATTESTATION is derived from the list length.
-SHARD_BLOCK_OFFSETS: [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
+# SHARD_BLOCK_OFFSETS: [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
 # len(SHARD_BLOCK_OFFSETS)
 MAX_SHARD_BLOCKS_PER_ATTESTATION: 12
 # 2**14 (= 16,384) Gwei
diff --git a/configs/minimal.yaml b/configs/minimal.yaml
index 42c63e301..48fab475c 100644
--- a/configs/minimal.yaml
+++ b/configs/minimal.yaml
@@ -180,7 +180,7 @@ MAX_SHARD_BLOCK_CHUNKS: 4
 # 3 * 2**16` (= 196,608)
 TARGET_SHARD_BLOCK_SIZE: 196608
 # Note: MAX_SHARD_BLOCKS_PER_ATTESTATION is derived from the list length.
-SHARD_BLOCK_OFFSETS: [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
+# SHARD_BLOCK_OFFSETS: [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
 # len(SHARD_BLOCK_OFFSETS)
 MAX_SHARD_BLOCKS_PER_ATTESTATION: 12
 # 2**14 (= 16,384) Gwei
diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index bdf70c5bd..897dae369 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -57,7 +57,7 @@
         - [`apply_shard_transition`](#apply_shard_transition)
         - [`process_crosslink_for_shard`](#process_crosslink_for_shard)
         - [`process_crosslinks`](#process_crosslinks)
-        - [`process_attestations`](#process_attestations)
+        - [`process_attestation`](#process_attestation)
       - [New Attester slashing processing](#new-attester-slashing-processing)
     - [Shard transition false positives](#shard-transition-false-positives)
     - [Light client processing](#light-client-processing)
@@ -98,7 +98,7 @@ Configuration is not namespaced. Instead it is strictly an extension;
 | `SHARD_COMMITTEE_PERIOD` | `Epoch(2**8)` (= 256) | epochs | ~27 hours |
 | `MAX_SHARD_BLOCK_SIZE` | `2**20` (= 1,048,576) | |
 | `TARGET_SHARD_BLOCK_SIZE` | `2**18` (= 262,144) | |
-| `SHARD_BLOCK_OFFSETS` | `[1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]` | |
+| `SHARD_BLOCK_OFFSETS` | `[0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]` | |
 | `MAX_SHARD_BLOCKS_PER_ATTESTATION` | `len(SHARD_BLOCK_OFFSETS)` | |
 | `MAX_GASPRICE` | `Gwei(2**14)` (= 16,384) | Gwei | |
 | `MIN_GASPRICE` | `Gwei(2**5)` (= 32) | Gwei | |
@@ -500,7 +500,6 @@ def get_next_slot_for_shard(state: BeaconState, shard: Shard) -> Slot:
     return Slot(state.shard_states[shard].slot + 1)
 ```
 
-
 #### `get_offset_slots`
 
 ```python
@@ -526,7 +525,7 @@ def is_valid_indexed_attestation(state: BeaconState, indexed_attestation: Indexe
     domain = get_domain(state, DOMAIN_BEACON_ATTESTER, attestation.data.target.epoch)
     aggregation_bits = attestation.aggregation_bits
     assert len(aggregation_bits) == len(indexed_attestation.committee)
-    
+
     if len(attestation.custody_bits_blocks) == 0:
         # fall back on phase0 behavior if there is no shard data.
         for participant, abit in zip(indexed_attestation.committee, aggregation_bits):
@@ -612,11 +611,9 @@ def validate_attestation(state: BeaconState, attestation: Attestation) -> None:
     shard = get_shard(state, attestation)
     shard_start_slot = get_next_slot_for_shard(state, shard)
 
-    # Signature check
-    assert is_valid_indexed_attestation(state, get_indexed_attestation(state, attestation))
     # Type 1: on-time attestations
     if attestation.custody_bits_blocks != []:
-        # Correct slot
+        # Ensure on-time attestation
         assert data.slot + MIN_ATTESTATION_INCLUSION_DELAY == state.slot
         # Correct data root count
         assert len(attestation.custody_bits_blocks) == len(get_offset_slots(state, shard_start_slot))
@@ -624,8 +621,14 @@ def validate_attestation(state: BeaconState, attestation: Attestation) -> None:
         assert data.beacon_block_root == get_block_root_at_slot(state, get_previous_slot(state.slot))
     # Type 2: no shard transition, no custody bits  # TODO: could only allow for older attestations.
     else:
-        # assert state.slot - compute_start_slot_at_epoch(compute_epoch_at_slot(data.slot)) < SLOTS_PER_EPOCH
+        # Ensure delayed attestation
+        # Currently commented out because breaks a ton of phase 0 tests
+        # assert data.slot + MIN_ATTESTATION_INCLUSION_DELAY < state.slot  
+        # Late attestations cannot have a shard transition root
         assert data.shard_transition_root == Root()
+
+    # Signature check
+    assert is_valid_indexed_attestation(state, get_indexed_attestation(state, attestation))
 ```
 
 ###### `apply_shard_transition`
diff --git a/tests/core/pyspec/eth2spec/test/helpers/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
index 9e12582e0..0a6e3294d 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/attestations.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
@@ -1,11 +1,47 @@
 from typing import List
 
 from eth2spec.test.helpers.block import build_empty_block_for_next_slot
+from eth2spec.test.context import expect_assertion_error
 from eth2spec.test.helpers.keys import privkeys
 from eth2spec.utils import bls
 from eth2spec.utils.ssz.ssz_typing import Bitlist
 
 
+def run_attestation_processing(spec, state, attestation, valid=True):
+    """
+    Run ``process_attestation``, yielding:
+      - pre-state ('pre')
+      - attestation ('attestation')
+      - post-state ('post').
+    If ``valid == False``, run expecting ``AssertionError``
+    """
+    # yield pre-state
+    yield 'pre', state
+
+    yield 'attestation', attestation
+
+    # If the attestation is invalid, processing is aborted, and there is no post-state.
+    if not valid:
+        expect_assertion_error(lambda: spec.process_attestation(state, attestation))
+        yield 'post', None
+        return
+
+    current_epoch_count = len(state.current_epoch_attestations)
+    previous_epoch_count = len(state.previous_epoch_attestations)
+
+    # process attestation
+    spec.process_attestation(state, attestation)
+
+    # Make sure the attestation has been processed
+    if attestation.data.target.epoch == spec.get_current_epoch(state):
+        assert len(state.current_epoch_attestations) == current_epoch_count + 1
+    else:
+        assert len(state.previous_epoch_attestations) == previous_epoch_count + 1
+
+    # yield post-state
+    yield 'post', state
+
+
 def build_attestation_data(spec, state, slot, index):
     assert state.slot >= slot
 
@@ -111,7 +147,6 @@ def get_attestation_signature(spec, state, attestation_data, privkey):
 
 
 def fill_aggregate_attestation(spec, state, attestation, signed=False):
-
     beacon_committee = spec.get_beacon_committee(
         state,
         attestation.data.slot,
diff --git a/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
index 622183fe9..204458342 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
@@ -1,30 +1,66 @@
-from eth2spec.test.helpers.keys import privkeys
+from eth2spec.utils.ssz.ssz_typing import Bitlist
 from eth2spec.utils import bls
 
+from eth2spec.test.helpers.keys import privkeys
+import eth2spec.test.helpers.attestations as phase0_attestations
+from eth2spec.test.helpers.state import next_slot
 
-def sign_shard_attestation(spec, beacon_state, shard_state, block, participants):
-    signatures = []
-    message_hash = spec.ShardAttestationData(
-        slot=block.slot,
-        parent_root=block.parent_root,
-    ).hash_tree_root()
-    block_epoch = spec.compute_epoch_of_shard_slot(block.slot)
-    for validator_index in participants:
-        privkey = privkeys[validator_index]
-        signatures.append(
-            get_attestation_signature(
-                spec,
-                beacon_state,
-                shard_state,
-                message_hash,
-                block_epoch,
-                privkey,
-            )
+
+def get_valid_on_time_attestation(spec, state, index=None, signed=False):
+    '''
+    Construct on-time attestation for next slot
+    '''
+    if index is None:
+        index = 0
+
+    attestation = phase0_attestations.get_valid_attestation(spec, state, state.slot, index, False)
+    shard = spec.get_shard(state, attestation)
+
+    next_state = state.copy()
+    next_slot(spec, next_state)
+    offset_slots = spec.get_offset_slots(next_state, spec.get_next_slot_for_shard(next_state, shard))
+    for offset_slot in offset_slots:
+        attestation.custody_bits_blocks.append(
+            Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE]([0 for _ in attestation.aggregation_bits])
         )
-    return bls.Aggregate(signatures)
+
+    if signed:
+        sign_attestation(spec, state, attestation)
+
+    return attestation
 
 
-def get_attestation_signature(spec, beacon_state, shard_state, message_hash, block_epoch, privkey):
-    domain = spec.get_domain(beacon_state, spec.DOMAIN_SHARD_ATTESTER, block_epoch)
-    signing_root = spec.compute_signing_root(message_hash, domain)
+def sign_attestation(spec, state, attestation):
+    if not any(attestation.custody_bits_blocks):
+        phase0_attestations.sign_attestation(spec, state, attestation)
+        return
+
+    committee = spec.get_beacon_committee(state, attestation.data.slot, attestation.data.index)
+    signatures = []
+    for block_index, custody_bits in enumerate(attestation.custody_bits_blocks):
+        for participant, abit, cbit in zip(committee, attestation.aggregation_bits, custody_bits):
+            if not abit:
+                continue
+            signatures.append(get_attestation_custody_signature(
+                spec,
+                state,
+                attestation.data,
+                block_index,
+                cbit,
+                privkeys[participant]
+            ))
+
+    attestation.signature = bls.Aggregate(signatures)
+
+
+def get_attestation_custody_signature(spec, state, attestation_data, block_index, bit, privkey):
+    domain = spec.get_domain(state, spec.DOMAIN_BEACON_ATTESTER, attestation_data.target.epoch)
+    signing_root = spec.compute_signing_root(
+        spec.AttestationCustodyBitWrapper(
+            attestation_data.hash_tree_root(),
+            block_index,
+            bit,
+        ),
+        domain,
+    )
     return bls.Sign(privkey, signing_root)
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
index 1dbdafec2..236fceef1 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
@@ -1,6 +1,5 @@
 from eth2spec.test.context import (
     spec_state_test,
-    expect_assertion_error,
     always_bls, never_bls,
     with_all_phases,
     spec_test,
@@ -8,6 +7,7 @@ from eth2spec.test.context import (
     with_custom_state,
     single_phase)
 from eth2spec.test.helpers.attestations import (
+    run_attestation_processing,
     get_valid_attestation,
     sign_aggregate_attestation,
     sign_attestation,
@@ -19,41 +19,6 @@ from eth2spec.test.helpers.block import apply_empty_block
 from eth2spec.utils.ssz.ssz_typing import Bitlist
 
 
-def run_attestation_processing(spec, state, attestation, valid=True):
-    """
-    Run ``process_attestation``, yielding:
-      - pre-state ('pre')
-      - attestation ('attestation')
-      - post-state ('post').
-    If ``valid == False``, run expecting ``AssertionError``
-    """
-    # yield pre-state
-    yield 'pre', state
-
-    yield 'attestation', attestation
-
-    # If the attestation is invalid, processing is aborted, and there is no post-state.
-    if not valid:
-        expect_assertion_error(lambda: spec.process_attestation(state, attestation))
-        yield 'post', None
-        return
-
-    current_epoch_count = len(state.current_epoch_attestations)
-    previous_epoch_count = len(state.previous_epoch_attestations)
-
-    # process attestation
-    spec.process_attestation(state, attestation)
-
-    # Make sure the attestation has been processed
-    if attestation.data.target.epoch == spec.get_current_epoch(state):
-        assert len(state.current_epoch_attestations) == current_epoch_count + 1
-    else:
-        assert len(state.previous_epoch_attestations) == previous_epoch_count + 1
-
-    # yield post-state
-    yield 'post', state
-
-
 @with_all_phases
 @spec_state_test
 def test_success(spec, state):
diff --git a/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py b/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py
index 875039c59..430ad014b 100644
--- a/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py
+++ b/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py
@@ -1,61 +1,26 @@
 from eth2spec.test.context import (
     with_all_phases_except,
-    expect_assertion_error,
     spec_state_test,
     always_bls,
 )
+from eth2spec.test.helpers.state import next_slot, transition_to
 from eth2spec.test.helpers.attestations import (
-    get_valid_attestation,
-    sign_attestation,
+    run_attestation_processing,
+    # get_valid_attestation as get_valid_late_attestation,
+)
+from eth2spec.test.helpers.phase1.attestations import (
+    get_valid_on_time_attestation,
 )
-
-from eth2spec.utils.ssz.ssz_typing import Bitlist
-
-
-def run_attestation_processing(spec, state, attestation, valid=True):
-    """
-    Run ``process_attestation``, yielding:
-      - pre-state ('pre')
-      - attestation ('attestation')
-      - post-state ('post').
-    If ``valid == False``, run expecting ``AssertionError``
-    """
-    # yield pre-state
-    yield 'pre', state
-
-    yield 'attestation', attestation
-
-    # If the attestation is invalid, processing is aborted, and there is no post-state.
-    if not valid:
-        expect_assertion_error(lambda: spec.process_attestation(state, attestation))
-        yield 'post', None
-        return
-
-    current_epoch_count = len(state.current_epoch_attestations)
-    previous_epoch_count = len(state.previous_epoch_attestations)
-
-    # process attestation
-    spec.process_attestation(state, attestation)
-
-    # Make sure the attestation has been processed
-    if attestation.data.target.epoch == spec.get_current_epoch(state):
-        assert len(state.current_epoch_attestations) == current_epoch_count + 1
-    else:
-        assert len(state.previous_epoch_attestations) == previous_epoch_count + 1
-
-    # yield post-state
-    yield 'post', state
 
 
 @with_all_phases_except(['phase0'])
 @spec_state_test
 @always_bls
-def test_success_empty_custody_bits_blocks(spec, state):
-    attestation = get_valid_attestation(spec, state)
-    attestation.custody_bits_blocks = []
-    sign_attestation(spec, state, attestation)
+def test_on_time_success(spec, state):
+    next_slot(spec, state)
+    attestation = get_valid_on_time_attestation(spec, state, signed=True)
 
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+    transition_to(spec, state, state.slot + spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     yield from run_attestation_processing(spec, state, attestation)
 
@@ -63,18 +28,28 @@ def test_success_empty_custody_bits_blocks(spec, state):
 @with_all_phases_except(['phase0'])
 @spec_state_test
 @always_bls
-def test_fail_custody_bits_blocks_incorrect_slot(spec, state):
-    attestation = get_valid_attestation(spec, state)
-    committee = spec.get_beacon_committee(
-        state,
-        attestation.data.slot,
-        attestation.data.index,
-    )
-    bitlist = Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE]([0 for _ in range(len(committee))])
-    bitlist[0] = 1
-    attestation.custody_bits_blocks = [bitlist]
-    sign_attestation(spec, state, attestation)
+def test_on_time_empty_custody_bits_blocks(spec, state):
+    # Causing this test to pass causes many phase0 tests to fail
+    pass
+    """
+    next_slot(spec, state)
+    attestation = get_valid_late_attestation(spec, state, signed=True)
 
-    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + 1
+    assert not any(attestation.custody_bits_blocks)
 
-    yield from run_attestation_processing(spec, state, attestation)
\ No newline at end of file
+    transition_to(spec, state, state.slot + spec.MIN_ATTESTATION_INCLUSION_DELAY)
+
+    yield from run_attestation_processing(spec, state, attestation, False)
+    """
+
+
+@with_all_phases_except(['phase0'])
+@spec_state_test
+@always_bls
+def test_late_with_custody_bits_blocks(spec, state):
+    next_slot(spec, state)
+    attestation = get_valid_on_time_attestation(spec, state, signed=True)
+
+    transition_to(spec, state, state.slot + spec.MIN_ATTESTATION_INCLUSION_DELAY + 1)
+
+    yield from run_attestation_processing(spec, state, attestation, False)

From 97fa3741af0ae919437532eba318b4326f33b9b9 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Sat, 22 Feb 2020 09:21:39 -0600
Subject: [PATCH 22/33] working through test issues

---
 specs/phase1/beacon-chain.md                  |   3 +-
 .../test/fork_choice/test_get_head.py         |   3 +-
 .../test/fork_choice/test_on_block.py         |   3 +-
 .../eth2spec/test/helpers/attestations.py     | 123 +++++++++++++++++-
 .../pyspec/eth2spec/test/helpers/state.py     |  32 -----
 .../test_process_attestation.py               |  11 +-
 .../test_process_attestation.py               |   8 +-
 .../pyspec/eth2spec/test/test_finality.py     |   3 +-
 8 files changed, 135 insertions(+), 51 deletions(-)

diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index 897dae369..fe5c0d9a7 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -622,8 +622,7 @@ def validate_attestation(state: BeaconState, attestation: Attestation) -> None:
     # Type 2: no shard transition, no custody bits  # TODO: could only allow for older attestations.
     else:
         # Ensure delayed attestation
-        # Currently commented out because breaks a ton of phase 0 tests
-        # assert data.slot + MIN_ATTESTATION_INCLUSION_DELAY < state.slot  
+        assert data.slot + MIN_ATTESTATION_INCLUSION_DELAY < state.slot  
         # Late attestations cannot have a shard transition root
         assert data.shard_transition_root == Root()
 
diff --git a/tests/core/pyspec/eth2spec/test/fork_choice/test_get_head.py b/tests/core/pyspec/eth2spec/test/fork_choice/test_get_head.py
index e34c32c0e..17d4f644f 100644
--- a/tests/core/pyspec/eth2spec/test/fork_choice/test_get_head.py
+++ b/tests/core/pyspec/eth2spec/test/fork_choice/test_get_head.py
@@ -1,9 +1,8 @@
 from eth2spec.test.context import with_all_phases, spec_state_test
-from eth2spec.test.helpers.attestations import get_valid_attestation
+from eth2spec.test.helpers.attestations import get_valid_attestation, next_epoch_with_attestations
 from eth2spec.test.helpers.block import build_empty_block_for_next_slot
 from eth2spec.test.helpers.state import (
     next_epoch,
-    next_epoch_with_attestations,
     state_transition_and_sign_block,
 )
 
diff --git a/tests/core/pyspec/eth2spec/test/fork_choice/test_on_block.py b/tests/core/pyspec/eth2spec/test/fork_choice/test_on_block.py
index f50a00a9f..3d824811c 100644
--- a/tests/core/pyspec/eth2spec/test/fork_choice/test_on_block.py
+++ b/tests/core/pyspec/eth2spec/test/fork_choice/test_on_block.py
@@ -4,7 +4,8 @@ from eth2spec.utils.ssz.ssz_impl import hash_tree_root
 from eth2spec.test.context import with_all_phases, spec_state_test
 from eth2spec.test.helpers.block import build_empty_block_for_next_slot, sign_block, transition_unsigned_block, \
     build_empty_block
-from eth2spec.test.helpers.state import next_epoch, next_epoch_with_attestations, state_transition_and_sign_block
+from eth2spec.test.helpers.attestations import next_epoch_with_attestations
+from eth2spec.test.helpers.state import next_epoch, state_transition_and_sign_block
 
 
 def run_on_block(spec, store, signed_block, valid=True):
diff --git a/tests/core/pyspec/eth2spec/test/helpers/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
index 0a6e3294d..8f11e3306 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/attestations.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
@@ -1,7 +1,8 @@
 from typing import List
 
-from eth2spec.test.helpers.block import build_empty_block_for_next_slot
 from eth2spec.test.context import expect_assertion_error
+from eth2spec.test.helpers.state import next_slot, state_transition_and_sign_block
+from eth2spec.test.helpers.block import build_empty_block_for_next_slot, transition_unsigned_block
 from eth2spec.test.helpers.keys import privkeys
 from eth2spec.utils import bls
 from eth2spec.utils.ssz.ssz_typing import Bitlist
@@ -74,7 +75,48 @@ def build_attestation_data(spec, state, slot, index):
     )
 
 
-def get_valid_attestation(spec, state, slot=None, index=None, signed=False):
+def convert_to_valid_on_time_attestation(spec, state, attestation, signed=False):
+    shard = spec.get_shard(state, attestation)
+
+    next_state = state.copy()
+    next_slot(spec, next_state)
+    offset_slots = spec.get_offset_slots(next_state, spec.get_next_slot_for_shard(next_state, shard))
+    for offset_slot in offset_slots:
+        attestation.custody_bits_blocks.append(
+            Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE]([0 for _ in attestation.aggregation_bits])
+        )
+
+    if signed:
+        sign_attestation(spec, state, attestation)
+
+    return attestation
+
+
+def get_valid_on_time_attestation(spec, state, slot=None, index=None, signed=False):
+    '''
+    Construct on-time attestation for next slot
+    '''
+    if slot is None:
+        slot = state.slot
+    if index is None:
+        index = 0
+
+    return get_valid_attestation(spec, state, slot, index, signed, True)
+
+
+def get_valid_late_attestation(spec, state, slot=None, index=None, signed=False):
+    '''
+    Construct on-time attestation for next slot
+    '''
+    if slot is None:
+        slot = state.slot
+    if index is None:
+        index = 0
+
+    return get_valid_attestation(spec, state, slot, index, signed, False)
+
+
+def get_valid_attestation(spec, state, slot=None, index=None, signed=False, on_time=True):
     if slot is None:
         slot = state.slot
     if index is None:
@@ -97,6 +139,10 @@ def get_valid_attestation(spec, state, slot=None, index=None, signed=False):
     fill_aggregate_attestation(spec, state, attestation)
     if signed:
         sign_attestation(spec, state, attestation)
+
+    if spec.fork == 'phase1' and on_time:
+        attestation = convert_to_valid_on_time_attestation(spec, state, attestation, signed)
+
     return attestation
 
 
@@ -112,7 +158,6 @@ def sign_aggregate_attestation(spec, state, attestation_data, participants: List
                 privkey
             )
         )
-    # TODO: we should try signing custody bits if spec.fork == 'phase1'
     return bls.Aggregate(signatures)
 
 
@@ -130,7 +175,47 @@ def sign_indexed_attestation(spec, state, indexed_attestation):
         indexed_attestation.attestation.signature = sign_aggregate_attestation(spec, state, data, participants)
 
 
+def sign_on_time_attestation(spec, state, attestation):
+    if not any(attestation.custody_bits_blocks):
+        sign_attestation(spec, state, attestation)
+        return
+
+    committee = spec.get_beacon_committee(state, attestation.data.slot, attestation.data.index)
+    signatures = []
+    for block_index, custody_bits in enumerate(attestation.custody_bits_blocks):
+        for participant, abit, cbit in zip(committee, attestation.aggregation_bits, custody_bits):
+            if not abit:
+                continue
+            signatures.append(get_attestation_custody_signature(
+                spec,
+                state,
+                attestation.data,
+                block_index,
+                cbit,
+                privkeys[participant]
+            ))
+
+    attestation.signature = bls.Aggregate(signatures)
+
+
+def get_attestation_custody_signature(spec, state, attestation_data, block_index, bit, privkey):
+    domain = spec.get_domain(state, spec.DOMAIN_BEACON_ATTESTER, attestation_data.target.epoch)
+    signing_root = spec.compute_signing_root(
+        spec.AttestationCustodyBitWrapper(
+            attestation_data.hash_tree_root(),
+            block_index,
+            bit,
+        ),
+        domain,
+    )
+    return bls.Sign(privkey, signing_root)
+
+
 def sign_attestation(spec, state, attestation):
+    if spec.fork == 'phase1' and any(attestation.custody_bits_blocks):
+        sign_on_time_attestation(spec, state,attestation)
+        return
+
     participants = spec.get_attesting_indices(
         state,
         attestation.data,
@@ -163,3 +248,35 @@ def add_attestations_to_state(spec, state, attestations, slot):
     spec.process_slots(state, slot)
     for attestation in attestations:
         spec.process_attestation(state, attestation)
+
+
+def next_epoch_with_attestations(spec,
+                                 state,
+                                 fill_cur_epoch,
+                                 fill_prev_epoch):
+    assert state.slot % spec.SLOTS_PER_EPOCH == 0
+
+    post_state = state.copy()
+    signed_blocks = []
+    for _ in range(spec.SLOTS_PER_EPOCH):
+        block = build_empty_block_for_next_slot(spec, post_state)
+        if fill_cur_epoch and post_state.slot >= spec.MIN_ATTESTATION_INCLUSION_DELAY:
+            slot_to_attest = post_state.slot - spec.MIN_ATTESTATION_INCLUSION_DELAY + 1
+            committees_per_slot = spec.get_committee_count_at_slot(state, slot_to_attest)
+            if slot_to_attest >= spec.compute_start_slot_at_epoch(spec.get_current_epoch(post_state)):
+                for index in range(committees_per_slot):
+                    cur_attestation = get_valid_attestation(spec, post_state, slot_to_attest, index=index, signed=True)
+                    block.body.attestations.append(cur_attestation)
+
+        if fill_prev_epoch:
+            slot_to_attest = post_state.slot - spec.SLOTS_PER_EPOCH + 1
+            committees_per_slot = spec.get_committee_count_at_slot(state, slot_to_attest)
+            for index in range(committees_per_slot):
+                prev_attestation = get_valid_attestation(
+                    spec, post_state, slot_to_attest, index=index, signed=True, on_time=False)
+                block.body.attestations.append(prev_attestation)
+
+        signed_block = state_transition_and_sign_block(spec, post_state, block)
+        signed_blocks.append(signed_block)
+
+    return state, signed_blocks, post_state
diff --git a/tests/core/pyspec/eth2spec/test/helpers/state.py b/tests/core/pyspec/eth2spec/test/helpers/state.py
index 5816785f7..9b5d132f9 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/state.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/state.py
@@ -1,5 +1,4 @@
 from eth2spec.test.context import expect_assertion_error
-from eth2spec.test.helpers.attestations import get_valid_attestation
 from eth2spec.test.helpers.block import sign_block, build_empty_block_for_next_slot, transition_unsigned_block
 
 
@@ -58,34 +57,3 @@ def state_transition_and_sign_block(spec, state, block, expect_fail=False):
         transition_unsigned_block(spec, state, block)
     block.state_root = state.hash_tree_root()
     return sign_block(spec, state, block)
-
-
-def next_epoch_with_attestations(spec,
-                                 state,
-                                 fill_cur_epoch,
-                                 fill_prev_epoch):
-    assert state.slot % spec.SLOTS_PER_EPOCH == 0
-
-    post_state = state.copy()
-    signed_blocks = []
-    for _ in range(spec.SLOTS_PER_EPOCH):
-        block = build_empty_block_for_next_slot(spec, post_state)
-        if fill_cur_epoch and post_state.slot >= spec.MIN_ATTESTATION_INCLUSION_DELAY:
-            slot_to_attest = post_state.slot - spec.MIN_ATTESTATION_INCLUSION_DELAY + 1
-            committees_per_slot = spec.get_committee_count_at_slot(state, slot_to_attest)
-            if slot_to_attest >= spec.compute_start_slot_at_epoch(spec.get_current_epoch(post_state)):
-                for index in range(committees_per_slot):
-                    cur_attestation = get_valid_attestation(spec, post_state, slot_to_attest, index=index, signed=True)
-                    block.body.attestations.append(cur_attestation)
-
-        if fill_prev_epoch:
-            slot_to_attest = post_state.slot - spec.SLOTS_PER_EPOCH + 1
-            committees_per_slot = spec.get_committee_count_at_slot(state, slot_to_attest)
-            for index in range(committees_per_slot):
-                prev_attestation = get_valid_attestation(spec, post_state, slot_to_attest, index=index, signed=True)
-                block.body.attestations.append(prev_attestation)
-
-        signed_block = state_transition_and_sign_block(spec, post_state, block)
-        signed_blocks.append(signed_block)
-
-    return state, signed_blocks, post_state
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
index 236fceef1..525f01fcc 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
@@ -13,7 +13,10 @@ from eth2spec.test.helpers.attestations import (
     sign_attestation,
 )
 from eth2spec.test.helpers.state import (
-    next_epoch, next_slots
+    next_epoch,
+    next_slots,
+    next_slot,
+    next_epoch,
 )
 from eth2spec.test.helpers.block import apply_empty_block
 from eth2spec.utils.ssz.ssz_typing import Bitlist
@@ -166,7 +169,7 @@ def test_old_target_epoch(spec, state):
 
     attestation = get_valid_attestation(spec, state, signed=True)
 
-    state.slot = spec.SLOTS_PER_EPOCH * 2  # target epoch will be too old to handle
+    transition_to(spec, state, state.slot + spec.SLOTS_PER_EPOCH * 2)  # target epoch will be too old to handle
 
     yield from run_attestation_processing(spec, state, attestation, False)
 
@@ -222,7 +225,8 @@ def test_source_root_is_target_root(spec, state):
 @with_all_phases
 @spec_state_test
 def test_invalid_current_source_root(spec, state):
-    state.slot = spec.SLOTS_PER_EPOCH * 5
+    transition_to(spec, state, state.slot + spec.SLOTS_PER_EPOCH * 5)
+
     state.finalized_checkpoint.epoch = 2
 
     state.previous_justified_checkpoint = spec.Checkpoint(epoch=3, root=b'\x01' * 32)
@@ -259,6 +263,7 @@ def test_bad_source_root(spec, state):
 @with_all_phases
 @spec_state_test
 def test_empty_aggregation_bits(spec, state):
+    next_slot(spec, state)
     attestation = get_valid_attestation(spec, state)
     next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
diff --git a/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py b/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py
index 430ad014b..288bb8e00 100644
--- a/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py
+++ b/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py
@@ -6,9 +6,7 @@ from eth2spec.test.context import (
 from eth2spec.test.helpers.state import next_slot, transition_to
 from eth2spec.test.helpers.attestations import (
     run_attestation_processing,
-    # get_valid_attestation as get_valid_late_attestation,
-)
-from eth2spec.test.helpers.phase1.attestations import (
+    get_valid_late_attestation,
     get_valid_on_time_attestation,
 )
 
@@ -29,9 +27,6 @@ def test_on_time_success(spec, state):
 @spec_state_test
 @always_bls
 def test_on_time_empty_custody_bits_blocks(spec, state):
-    # Causing this test to pass causes many phase0 tests to fail
-    pass
-    """
     next_slot(spec, state)
     attestation = get_valid_late_attestation(spec, state, signed=True)
 
@@ -40,7 +35,6 @@ def test_on_time_empty_custody_bits_blocks(spec, state):
     transition_to(spec, state, state.slot + spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     yield from run_attestation_processing(spec, state, attestation, False)
-    """
 
 
 @with_all_phases_except(['phase0'])
diff --git a/tests/core/pyspec/eth2spec/test/test_finality.py b/tests/core/pyspec/eth2spec/test/test_finality.py
index 8ae50d436..d793b6656 100644
--- a/tests/core/pyspec/eth2spec/test/test_finality.py
+++ b/tests/core/pyspec/eth2spec/test/test_finality.py
@@ -1,5 +1,6 @@
 from eth2spec.test.context import spec_state_test, never_bls, with_all_phases
-from eth2spec.test.helpers.state import next_epoch, next_epoch_with_attestations
+from eth2spec.test.helpers.state import next_epoch
+from eth2spec.test.helpers.attestations import next_epoch_with_attestations
 from eth2spec.test.helpers.block import apply_empty_block
 
 

From 4c1fc9bffaafaa388739cd1369804abbe342acd3 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Sat, 22 Feb 2020 12:06:31 -0600
Subject: [PATCH 23/33] work through phase 1 tests

---
 specs/phase0/fork-choice.md                   |  4 ++-
 specs/phase1/beacon-chain.md                  |  3 +++
 tests/core/pyspec/eth2spec/test/context.py    |  4 ++-
 .../test/fork_choice/test_on_attestation.py   | 18 +++++++------
 .../test/fork_choice/test_on_block.py         |  1 +
 .../eth2spec/test/fork_choice/test_on_tick.py |  6 +++--
 .../eth2spec/test/helpers/attestations.py     |  4 +--
 .../pyspec/eth2spec/test/helpers/state.py     |  2 +-
 .../test_process_attestation.py               | 24 ++++++++---------
 .../test_process_attester_slashing.py         |  4 +++
 .../test_process_rewards_and_penalties.py     | 26 +++++++++++++------
 .../test_process_attestation.py               |  5 +---
 .../eth2spec/test/sanity/test_blocks.py       |  2 +-
 .../pyspec/eth2spec/test/test_finality.py     |  4 +--
 14 files changed, 65 insertions(+), 42 deletions(-)

diff --git a/specs/phase0/fork-choice.md b/specs/phase0/fork-choice.md
index 79d37f28d..d8aaed14f 100644
--- a/specs/phase0/fork-choice.md
+++ b/specs/phase0/fork-choice.md
@@ -104,7 +104,7 @@ def get_forkchoice_store(anchor_state: BeaconState) -> Store:
     justified_checkpoint = Checkpoint(epoch=anchor_epoch, root=anchor_root)
     finalized_checkpoint = Checkpoint(epoch=anchor_epoch, root=anchor_root)
     return Store(
-        time=anchor_state.genesis_time,
+        time=anchor_state.genesis_time + SECONDS_PER_SLOT * anchor_state.slot,
         genesis_time=anchor_state.genesis_time,
         justified_checkpoint=justified_checkpoint,
         finalized_checkpoint=finalized_checkpoint,
@@ -317,11 +317,13 @@ def update_latest_messages(store: Store, attesting_indices: Sequence[ValidatorIn
 ```python
 def on_tick(store: Store, time: uint64) -> None:
     previous_slot = get_current_slot(store)
+    print(previous_slot)
 
     # update store time
     store.time = time
 
     current_slot = get_current_slot(store)
+    print(current_slot)
     # Not a new epoch, return
     if not (current_slot > previous_slot and compute_slots_since_epoch_start(current_slot) == 0):
         return
diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index fe5c0d9a7..fcd703a96 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -544,6 +544,9 @@ def is_valid_indexed_attestation(state: BeaconState, indexed_attestation: Indexe
                         AttestationCustodyBitWrapper(hash_tree_root(attestation.data), i, cbit), domain))
                 else:
                     assert not cbit
+        print(all_pubkeys)
+        print(all_signing_roots)
+        print(attestation.signature)
         return bls.AggregateVerify(zip(all_pubkeys, all_signing_roots), signature=attestation.signature)
 ```
 
diff --git a/tests/core/pyspec/eth2spec/test/context.py b/tests/core/pyspec/eth2spec/test/context.py
index 5338ccb9d..c4ce15ed8 100644
--- a/tests/core/pyspec/eth2spec/test/context.py
+++ b/tests/core/pyspec/eth2spec/test/context.py
@@ -54,7 +54,9 @@ def with_custom_state(balances_fn: Callable[[Any], Sequence[int]],
                     # TODO: instead of upgrading a test phase0 genesis state we can also write a phase1 state helper.
                     # Decide based on performance/consistency results later.
                     state = phases["phase1"].upgrade_to_phase1(state)
-
+                    # Shard state slot must lag behind BeaconState slot by at least 1
+                    # Will handle this more elegantly with fork mechanics
+                    spec.process_slots(state, state.slot + 1)
                 kw['state'] = state
             except KeyError:
                 raise TypeError('Spec decorator must come within state decorator to inject spec into state.')
diff --git a/tests/core/pyspec/eth2spec/test/fork_choice/test_on_attestation.py b/tests/core/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
index 87a39a620..e77c08892 100644
--- a/tests/core/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
+++ b/tests/core/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
@@ -120,11 +120,12 @@ def test_on_attestation_mismatched_target_and_slot(spec, state):
 @spec_state_test
 def test_on_attestation_target_not_in_store(spec, state):
     store = spec.get_forkchoice_store(state)
-    time = spec.SECONDS_PER_SLOT * spec.SLOTS_PER_EPOCH
+    time = store.time + spec.SECONDS_PER_SLOT * spec.SLOTS_PER_EPOCH
     spec.on_tick(store, time)
 
     # move to immediately before next epoch to make block new target
-    transition_to(spec, state, state.slot + spec.SLOTS_PER_EPOCH - 1)
+    next_epoch = spec.get_current_epoch(state) + 1
+    transition_to(spec, state, spec.compute_start_slot_at_epoch(next_epoch) - 1)
 
     target_block = build_empty_block_for_next_slot(spec, state)
     state_transition_and_sign_block(spec, state, target_block)
@@ -141,11 +142,12 @@ def test_on_attestation_target_not_in_store(spec, state):
 @spec_state_test
 def test_on_attestation_beacon_block_not_in_store(spec, state):
     store = spec.get_forkchoice_store(state)
-    time = spec.SECONDS_PER_SLOT * spec.SLOTS_PER_EPOCH
+    time = store.time + spec.SECONDS_PER_SLOT * spec.SLOTS_PER_EPOCH
     spec.on_tick(store, time)
 
     # move to immediately before next epoch to make block new target
-    transition_to(spec, state, state.slot + spec.SLOTS_PER_EPOCH - 1)
+    next_epoch = spec.get_current_epoch(state) + 1
+    transition_to(spec, state, spec.compute_start_slot_at_epoch(next_epoch) - 1)
 
     target_block = build_empty_block_for_next_slot(spec, state)
     signed_target_block = state_transition_and_sign_block(spec, state, target_block)
@@ -169,7 +171,7 @@ def test_on_attestation_beacon_block_not_in_store(spec, state):
 @spec_state_test
 def test_on_attestation_future_epoch(spec, state):
     store = spec.get_forkchoice_store(state)
-    time = 3 * spec.SECONDS_PER_SLOT
+    time = store.time + 3 * spec.SECONDS_PER_SLOT
     spec.on_tick(store, time)
 
     block = build_empty_block_for_next_slot(spec, state)
@@ -189,7 +191,7 @@ def test_on_attestation_future_epoch(spec, state):
 @spec_state_test
 def test_on_attestation_future_block(spec, state):
     store = spec.get_forkchoice_store(state)
-    time = spec.SECONDS_PER_SLOT * 5
+    time = store.time + spec.SECONDS_PER_SLOT * 5
     spec.on_tick(store, time)
 
     block = build_empty_block_for_next_slot(spec, state)
@@ -209,7 +211,7 @@ def test_on_attestation_future_block(spec, state):
 @spec_state_test
 def test_on_attestation_same_slot(spec, state):
     store = spec.get_forkchoice_store(state)
-    time = 1 * spec.SECONDS_PER_SLOT
+    time = store.time + spec.SECONDS_PER_SLOT
     spec.on_tick(store, time)
 
     block = build_empty_block_for_next_slot(spec, state)
@@ -225,7 +227,7 @@ def test_on_attestation_same_slot(spec, state):
 @spec_state_test
 def test_on_attestation_invalid_attestation(spec, state):
     store = spec.get_forkchoice_store(state)
-    time = 3 * spec.SECONDS_PER_SLOT
+    time = store.time + 3 * spec.SECONDS_PER_SLOT
     spec.on_tick(store, time)
 
     block = build_empty_block_for_next_slot(spec, state)
diff --git a/tests/core/pyspec/eth2spec/test/fork_choice/test_on_block.py b/tests/core/pyspec/eth2spec/test/fork_choice/test_on_block.py
index 3d824811c..4438dff92 100644
--- a/tests/core/pyspec/eth2spec/test/fork_choice/test_on_block.py
+++ b/tests/core/pyspec/eth2spec/test/fork_choice/test_on_block.py
@@ -160,6 +160,7 @@ def test_on_block_finalized_skip_slots(spec, state):
 @spec_state_test
 def test_on_block_finalized_skip_slots_not_in_skip_chain(spec, state):
     # Initialization
+    next_epoch(spec, state)
     store = spec.get_forkchoice_store(state)
 
     store.finalized_checkpoint = spec.Checkpoint(
diff --git a/tests/core/pyspec/eth2spec/test/fork_choice/test_on_tick.py b/tests/core/pyspec/eth2spec/test/fork_choice/test_on_tick.py
index 27b64ac09..93f3bd9bb 100644
--- a/tests/core/pyspec/eth2spec/test/fork_choice/test_on_tick.py
+++ b/tests/core/pyspec/eth2spec/test/fork_choice/test_on_tick.py
@@ -27,14 +27,16 @@ def test_basic(spec, state):
 @spec_state_test
 def test_update_justified_single(spec, state):
     store = spec.get_forkchoice_store(state)
-    seconds_per_epoch = spec.SECONDS_PER_SLOT * spec.SLOTS_PER_EPOCH
+    next_epoch = spec.get_current_epoch(state) + 1
+    next_epoch_start_slot = spec.compute_start_slot_at_epoch(next_epoch)
+    seconds_until_next_epoch = next_epoch_start_slot * spec.SECONDS_PER_SLOT - store.time
 
     store.best_justified_checkpoint = spec.Checkpoint(
         epoch=store.justified_checkpoint.epoch + 1,
         root=b'\x55' * 32,
     )
 
-    run_on_tick(spec, store, store.time + seconds_per_epoch, True)
+    run_on_tick(spec, store, store.time + seconds_until_next_epoch, True)
 
 
 @with_all_phases
diff --git a/tests/core/pyspec/eth2spec/test/helpers/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
index 8f11e3306..deebd0356 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/attestations.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
@@ -2,7 +2,7 @@ from typing import List
 
 from eth2spec.test.context import expect_assertion_error
 from eth2spec.test.helpers.state import next_slot, state_transition_and_sign_block
-from eth2spec.test.helpers.block import build_empty_block_for_next_slot, transition_unsigned_block
+from eth2spec.test.helpers.block import build_empty_block_for_next_slot
 from eth2spec.test.helpers.keys import privkeys
 from eth2spec.utils import bls
 from eth2spec.utils.ssz.ssz_typing import Bitlist
@@ -213,7 +213,7 @@ def get_attestation_custody_signature(spec, state, attestation_data, block_index
 
 def sign_attestation(spec, state, attestation):
     if spec.fork == 'phase1' and any(attestation.custody_bits_blocks):
-        sign_on_time_attestation(spec, state,attestation)
+        sign_on_time_attestation(spec, state, attestation)
         return
 
     participants = spec.get_attesting_indices(
diff --git a/tests/core/pyspec/eth2spec/test/helpers/state.py b/tests/core/pyspec/eth2spec/test/helpers/state.py
index 9b5d132f9..46a7ce2b5 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/state.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/state.py
@@ -1,5 +1,5 @@
 from eth2spec.test.context import expect_assertion_error
-from eth2spec.test.helpers.block import sign_block, build_empty_block_for_next_slot, transition_unsigned_block
+from eth2spec.test.helpers.block import sign_block, transition_unsigned_block
 
 
 def get_balance(state, index):
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
index 525f01fcc..9528ff6eb 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py
@@ -13,10 +13,10 @@ from eth2spec.test.helpers.attestations import (
     sign_attestation,
 )
 from eth2spec.test.helpers.state import (
-    next_epoch,
-    next_slots,
     next_slot,
+    next_slots,
     next_epoch,
+    transition_to,
 )
 from eth2spec.test.helpers.block import apply_empty_block
 from eth2spec.utils.ssz.ssz_typing import Bitlist
@@ -46,8 +46,8 @@ def test_success_multi_proposer_index_iterations(spec, state):
 @with_all_phases
 @spec_state_test
 def test_success_previous_epoch(spec, state):
-    attestation = get_valid_attestation(spec, state, signed=True)
-    state.slot = spec.SLOTS_PER_EPOCH - 1
+    attestation = get_valid_attestation(spec, state, signed=True, on_time=False)
+    transition_to(spec, state, spec.SLOTS_PER_EPOCH - 1)
     next_epoch(spec, state)
     apply_empty_block(spec, state)
 
@@ -76,10 +76,10 @@ def test_before_inclusion_delay(spec, state):
 @with_all_phases
 @spec_state_test
 def test_after_epoch_slots(spec, state):
-    attestation = get_valid_attestation(spec, state, signed=True)
-    state.slot = spec.SLOTS_PER_EPOCH - 1
+    attestation = get_valid_attestation(spec, state, signed=True, on_time=False)
+
     # increment past latest inclusion slot
-    spec.process_slots(state, state.slot + 2)
+    transition_to(spec, state, state.slot + spec.SLOTS_PER_EPOCH + 1)
     apply_empty_block(spec, state)
 
     yield from run_attestation_processing(spec, state, attestation, False)
@@ -154,7 +154,7 @@ def test_mismatched_target_and_slot(spec, state):
     next_epoch(spec, state)
     next_epoch(spec, state)
 
-    attestation = get_valid_attestation(spec, state)
+    attestation = get_valid_attestation(spec, state, on_time=False)
     attestation.data.slot = attestation.data.slot - spec.SLOTS_PER_EPOCH
 
     sign_attestation(spec, state, attestation)
@@ -167,9 +167,9 @@ def test_mismatched_target_and_slot(spec, state):
 def test_old_target_epoch(spec, state):
     assert spec.MIN_ATTESTATION_INCLUSION_DELAY < spec.SLOTS_PER_EPOCH * 2
 
-    attestation = get_valid_attestation(spec, state, signed=True)
+    attestation = get_valid_attestation(spec, state, signed=True, on_time=False)
 
-    transition_to(spec, state, state.slot + spec.SLOTS_PER_EPOCH * 2)  # target epoch will be too old to handle
+    next_slots(spec, state, spec.SLOTS_PER_EPOCH * 2)  # target epoch will be too old to handle
 
     yield from run_attestation_processing(spec, state, attestation, False)
 
@@ -225,14 +225,14 @@ def test_source_root_is_target_root(spec, state):
 @with_all_phases
 @spec_state_test
 def test_invalid_current_source_root(spec, state):
-    transition_to(spec, state, state.slot + spec.SLOTS_PER_EPOCH * 5)
+    next_slots(spec, state, spec.SLOTS_PER_EPOCH * 5)
 
     state.finalized_checkpoint.epoch = 2
 
     state.previous_justified_checkpoint = spec.Checkpoint(epoch=3, root=b'\x01' * 32)
     state.current_justified_checkpoint = spec.Checkpoint(epoch=4, root=b'\x32' * 32)
 
-    attestation = get_valid_attestation(spec, state, slot=(spec.SLOTS_PER_EPOCH * 3) + 1)
+    attestation = get_valid_attestation(spec, state, slot=(spec.SLOTS_PER_EPOCH * 3) + 1, on_time=False)
     next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY)
 
     # Test logic sanity checks:
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py
index e9665e714..c379bb815 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py
@@ -143,6 +143,10 @@ def test_invalid_sig_1(spec, state):
 @always_bls
 def test_invalid_sig_2(spec, state):
     attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=False)
+    """
+    SOMETHING WRONG WITH HASH CACHE OF SEPARATE ATTESTATIONS MAKING SIGS
+    LOOK CORRECT
+    """
     yield from run_attester_slashing_processing(spec, state, attester_slashing, False)
 
 
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py
index 7cdeb16d9..044390b4b 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py
@@ -1,7 +1,10 @@
 from copy import deepcopy
 
-from eth2spec.test.context import spec_state_test, with_all_phases, spec_test, \
+from eth2spec.test.context import (
+    spec_state_test, spec_test,
+    with_all_phases, with_phases,
     misc_balances, with_custom_state, default_activation_threshold, single_phase
+)
 from eth2spec.test.helpers.state import (
     next_epoch,
     next_slot,
@@ -19,27 +22,30 @@ def run_process_rewards_and_penalties(spec, state):
 
 
 def prepare_state_with_full_attestations(spec, state):
+    start_slot = state.slot
+    start_epoch = spec.get_current_epoch(state)
+    next_start_epoch = spec.compute_start_slot_at_epoch(start_epoch + 1)
     attestations = []
     for slot in range(spec.SLOTS_PER_EPOCH + spec.MIN_ATTESTATION_INCLUSION_DELAY):
         # create an attestation for each index in each slot in epoch
-        if slot < spec.SLOTS_PER_EPOCH:
-            for committee_index in range(spec.get_committee_count_at_slot(state, slot)):
+        if state.slot < next_start_epoch:
+            for committee_index in range(spec.get_committee_count_at_slot(state, state.slot)):
                 attestation = get_valid_attestation(spec, state, index=committee_index, signed=True)
                 attestations.append(attestation)
         # fill each created slot in state after inclusion delay
-        if slot - spec.MIN_ATTESTATION_INCLUSION_DELAY >= 0:
-            inclusion_slot = slot - spec.MIN_ATTESTATION_INCLUSION_DELAY
+        if state.slot >= start_slot + spec.MIN_ATTESTATION_INCLUSION_DELAY:
+            inclusion_slot = state.slot - spec.MIN_ATTESTATION_INCLUSION_DELAY
             include_attestations = [att for att in attestations if att.data.slot == inclusion_slot]
             add_attestations_to_state(spec, state, include_attestations, state.slot)
         next_slot(spec, state)
 
-    assert spec.compute_epoch_at_slot(state.slot) == spec.GENESIS_EPOCH + 1
+    assert spec.compute_epoch_at_slot(state.slot) == start_epoch + 1
     assert len(state.previous_epoch_attestations) == len(attestations)
 
     return attestations
 
 
-@with_all_phases
+@with_phases(['phase0'])
 @spec_state_test
 def test_genesis_epoch_no_attestations_no_penalties(spec, state):
     pre_state = deepcopy(state)
@@ -52,7 +58,7 @@ def test_genesis_epoch_no_attestations_no_penalties(spec, state):
         assert state.balances[index] == pre_state.balances[index]
 
 
-@with_all_phases
+@with_phases(['phase0'])
 @spec_state_test
 def test_genesis_epoch_full_attestations_no_rewards(spec, state):
     attestations = []
@@ -81,6 +87,8 @@ def test_genesis_epoch_full_attestations_no_rewards(spec, state):
 @with_all_phases
 @spec_state_test
 def test_full_attestations(spec, state):
+    # Go to start of next epoch to ensure can have full participation
+    next_epoch(spec, state)
     attestations = prepare_state_with_full_attestations(spec, state)
 
     pre_state = deepcopy(state)
@@ -101,6 +109,8 @@ def test_full_attestations(spec, state):
 @with_custom_state(balances_fn=misc_balances, threshold_fn=default_activation_threshold)
 @single_phase
 def test_full_attestations_misc_balances(spec, state):
+    # Go to start of next epoch to ensure can have full participation
+    next_epoch(spec, state)
     attestations = prepare_state_with_full_attestations(spec, state)
 
     pre_state = deepcopy(state)
diff --git a/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py b/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py
index 288bb8e00..ed4328327 100644
--- a/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py
+++ b/tests/core/pyspec/eth2spec/test/phase_1/block_processing/test_process_attestation.py
@@ -3,7 +3,7 @@ from eth2spec.test.context import (
     spec_state_test,
     always_bls,
 )
-from eth2spec.test.helpers.state import next_slot, transition_to
+from eth2spec.test.helpers.state import transition_to
 from eth2spec.test.helpers.attestations import (
     run_attestation_processing,
     get_valid_late_attestation,
@@ -15,7 +15,6 @@ from eth2spec.test.helpers.attestations import (
 @spec_state_test
 @always_bls
 def test_on_time_success(spec, state):
-    next_slot(spec, state)
     attestation = get_valid_on_time_attestation(spec, state, signed=True)
 
     transition_to(spec, state, state.slot + spec.MIN_ATTESTATION_INCLUSION_DELAY)
@@ -27,7 +26,6 @@ def test_on_time_success(spec, state):
 @spec_state_test
 @always_bls
 def test_on_time_empty_custody_bits_blocks(spec, state):
-    next_slot(spec, state)
     attestation = get_valid_late_attestation(spec, state, signed=True)
 
     assert not any(attestation.custody_bits_blocks)
@@ -41,7 +39,6 @@ def test_on_time_empty_custody_bits_blocks(spec, state):
 @spec_state_test
 @always_bls
 def test_late_with_custody_bits_blocks(spec, state):
-    next_slot(spec, state)
     attestation = get_valid_on_time_attestation(spec, state, signed=True)
 
     transition_to(spec, state, state.slot + spec.MIN_ATTESTATION_INCLUSION_DELAY + 1)
diff --git a/tests/core/pyspec/eth2spec/test/sanity/test_blocks.py b/tests/core/pyspec/eth2spec/test/sanity/test_blocks.py
index e533b3b0a..156dc1581 100644
--- a/tests/core/pyspec/eth2spec/test/sanity/test_blocks.py
+++ b/tests/core/pyspec/eth2spec/test/sanity/test_blocks.py
@@ -381,7 +381,7 @@ def test_attestation(spec, state):
 
     # Add to state via block transition
     pre_current_attestations_len = len(state.current_epoch_attestations)
-    attestation_block = build_empty_block(spec, state, state.slot + 1 + spec.MIN_ATTESTATION_INCLUSION_DELAY)
+    attestation_block = build_empty_block(spec, state, state.slot + spec.MIN_ATTESTATION_INCLUSION_DELAY)
     attestation_block.body.attestations.append(attestation)
     signed_attestation_block = state_transition_and_sign_block(spec, state, attestation_block)
 
diff --git a/tests/core/pyspec/eth2spec/test/test_finality.py b/tests/core/pyspec/eth2spec/test/test_finality.py
index d793b6656..0b99cc3f9 100644
--- a/tests/core/pyspec/eth2spec/test/test_finality.py
+++ b/tests/core/pyspec/eth2spec/test/test_finality.py
@@ -1,4 +1,4 @@
-from eth2spec.test.context import spec_state_test, never_bls, with_all_phases
+from eth2spec.test.context import spec_state_test, never_bls, with_all_phases, with_phases
 from eth2spec.test.helpers.state import next_epoch
 from eth2spec.test.helpers.attestations import next_epoch_with_attestations
 from eth2spec.test.helpers.block import apply_empty_block
@@ -29,7 +29,7 @@ def check_finality(spec,
         assert state.finalized_checkpoint == prev_state.finalized_checkpoint
 
 
-@with_all_phases
+@with_phases(["phase0"])
 @spec_state_test
 @never_bls
 def test_finality_no_updates_at_genesis(spec, state):

From 9718d206a798a503983fcff43269024e6b474181 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 26 Feb 2020 11:20:19 -0600
Subject: [PATCH 24/33] fix attester slahsing test

---
 specs/phase1/beacon-chain.md                             | 9 +++++++--
 tests/core/pyspec/eth2spec/test/helpers/attestations.py  | 6 +++---
 .../block_processing/test_process_attester_slashing.py   | 4 ----
 3 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index fe5c0d9a7..c30810864 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -540,8 +540,12 @@ def is_valid_indexed_attestation(state: BeaconState, indexed_attestation: Indexe
                 if abit:
                     all_pubkeys.append(state.validators[participant].pubkey)
                     # Note: only 2N distinct message hashes
-                    all_signing_roots.append(compute_signing_root(
-                        AttestationCustodyBitWrapper(hash_tree_root(attestation.data), i, cbit), domain))
+                    attestation_wrapper = AttestationCustodyBitWrapper(
+                        attestation_data_root=hash_tree_root(attestation.data),
+                        block_index=i,
+                        bit=cbit
+                    )
+                    all_signing_roots.append(compute_signing_root(attestation_wrapper, domain))
                 else:
                     assert not cbit
         return bls.AggregateVerify(zip(all_pubkeys, all_signing_roots), signature=attestation.signature)
@@ -801,6 +805,7 @@ def get_indices_from_committee(
 def process_attester_slashing(state: BeaconState, attester_slashing: AttesterSlashing) -> None:
     indexed_attestation_1 = attester_slashing.attestation_1
     indexed_attestation_2 = attester_slashing.attestation_2
+
     assert is_slashable_attestation_data(
         indexed_attestation_1.attestation.data,
         indexed_attestation_2.attestation.data,
diff --git a/tests/core/pyspec/eth2spec/test/helpers/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
index deebd0356..fea4ea1f6 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/attestations.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
@@ -202,9 +202,9 @@ def get_attestation_custody_signature(spec, state, attestation_data, block_index
     domain = spec.get_domain(state, spec.DOMAIN_BEACON_ATTESTER, attestation_data.target.epoch)
     signing_root = spec.compute_signing_root(
         spec.AttestationCustodyBitWrapper(
-            attestation_data.hash_tree_root(),
-            block_index,
-            bit,
+            attestation_data_root=attestation_data.hash_tree_root(),
+            block_index=block_index,
+            bit=bit,
         ),
         domain,
     )
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py
index c379bb815..e9665e714 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py
@@ -143,10 +143,6 @@ def test_invalid_sig_1(spec, state):
 @always_bls
 def test_invalid_sig_2(spec, state):
     attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=False)
-    """
-    SOMETHING WRONG WITH HASH CACHE OF SEPARATE ATTESTATIONS MAKING SIGS
-    LOOK CORRECT
-    """
     yield from run_attester_slashing_processing(spec, state, attester_slashing, False)
 
 

From 63687e6f34565d2b5f045cdbda711c937932a3bd Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Fri, 28 Feb 2020 12:27:00 -0600
Subject: [PATCH 25/33] fix YAML parsed list of ints

---
 configs/mainnet.yaml                             | 2 +-
 configs/minimal.yaml                             | 2 +-
 tests/core/pyspec/eth2spec/config/config_util.py | 3 ++-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/configs/mainnet.yaml b/configs/mainnet.yaml
index c7940bceb..74f062d9b 100644
--- a/configs/mainnet.yaml
+++ b/configs/mainnet.yaml
@@ -179,7 +179,7 @@ MAX_SHARD_BLOCK_CHUNKS: 4
 # 3 * 2**16` (= 196,608)
 TARGET_SHARD_BLOCK_SIZE: 196608
 # Note: MAX_SHARD_BLOCKS_PER_ATTESTATION is derived from the list length.
-# SHARD_BLOCK_OFFSETS: [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
+SHARD_BLOCK_OFFSETS: [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
 # len(SHARD_BLOCK_OFFSETS)
 MAX_SHARD_BLOCKS_PER_ATTESTATION: 12
 # 2**14 (= 16,384) Gwei
diff --git a/configs/minimal.yaml b/configs/minimal.yaml
index 48fab475c..42c63e301 100644
--- a/configs/minimal.yaml
+++ b/configs/minimal.yaml
@@ -180,7 +180,7 @@ MAX_SHARD_BLOCK_CHUNKS: 4
 # 3 * 2**16` (= 196,608)
 TARGET_SHARD_BLOCK_SIZE: 196608
 # Note: MAX_SHARD_BLOCKS_PER_ATTESTATION is derived from the list length.
-# SHARD_BLOCK_OFFSETS: [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
+SHARD_BLOCK_OFFSETS: [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
 # len(SHARD_BLOCK_OFFSETS)
 MAX_SHARD_BLOCKS_PER_ATTESTATION: 12
 # 2**14 (= 16,384) Gwei
diff --git a/tests/core/pyspec/eth2spec/config/config_util.py b/tests/core/pyspec/eth2spec/config/config_util.py
index 42ad76d69..64c533f2d 100644
--- a/tests/core/pyspec/eth2spec/config/config_util.py
+++ b/tests/core/pyspec/eth2spec/config/config_util.py
@@ -36,7 +36,8 @@ def load_config_file(configs_dir, presets_name) -> Dict[str, Any]:
     out = dict()
     for k, v in loaded.items():
         if isinstance(v, list):
-            out[k] = v
+            # Clean up integer values. YAML parser renders lists of ints as list of str
+            out[k] = [int(item) if item.isdigit() else item for item in v]
         elif isinstance(v, str) and v.startswith("0x"):
             out[k] = bytes.fromhex(v[2:])
         else:

From 186d4258b697105608d2acdf24480826f7635417 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Fri, 28 Feb 2020 13:20:37 -0600
Subject: [PATCH 26/33] fix shard offsets

---
 specs/phase1/beacon-chain.md                  | 26 +++++++++----------
 .../eth2spec/test/helpers/attestations.py     |  2 +-
 .../test/helpers/phase1/attestations.py       |  2 +-
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index c30810864..66d94bfe9 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -46,7 +46,7 @@
     - [`get_updated_gasprice`](#get_updated_gasprice)
     - [`get_start_shard`](#get_start_shard)
     - [`get_shard`](#get_shard)
-    - [`get_next_slot_for_shard`](#get_next_slot_for_shard)
+    - [`get_latest_slot_for_shard`](#get_latest_slot_for_shard)
     - [`get_offset_slots`](#get_offset_slots)
   - [Predicates](#predicates)
     - [Updated `is_valid_indexed_attestation`](#updated-is_valid_indexed_attestation)
@@ -98,7 +98,7 @@ Configuration is not namespaced. Instead it is strictly an extension;
 | `SHARD_COMMITTEE_PERIOD` | `Epoch(2**8)` (= 256) | epochs | ~27 hours |
 | `MAX_SHARD_BLOCK_SIZE` | `2**20` (= 1,048,576) | |
 | `TARGET_SHARD_BLOCK_SIZE` | `2**18` (= 262,144) | |
-| `SHARD_BLOCK_OFFSETS` | `[0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]` | |
+| `SHARD_BLOCK_OFFSETS` | `[1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]` | |
 | `MAX_SHARD_BLOCKS_PER_ATTESTATION` | `len(SHARD_BLOCK_OFFSETS)` | |
 | `MAX_GASPRICE` | `Gwei(2**14)` (= 16,384) | Gwei | |
 | `MIN_GASPRICE` | `Gwei(2**5)` (= 32) | Gwei | |
@@ -493,18 +493,18 @@ def get_shard(state: BeaconState, attestation: Attestation) -> Shard:
     return compute_shard_from_committee_index(state, attestation.data.index, attestation.data.slot)
 ```
 
-#### `get_next_slot_for_shard`
+#### `get_latest_slot_for_shard`
 
 ```python
-def get_next_slot_for_shard(state: BeaconState, shard: Shard) -> Slot:
-    return Slot(state.shard_states[shard].slot + 1)
+def get_latest_slot_for_shard(state: BeaconState, shard: Shard) -> Slot:
+    return state.shard_states[shard].slot
 ```
 
 #### `get_offset_slots`
 
 ```python
-def get_offset_slots(state: BeaconState, start_slot: Slot) -> Sequence[Slot]:
-    return [Slot(start_slot + x) for x in SHARD_BLOCK_OFFSETS if start_slot + x < state.slot]
+def get_offset_slots(state: BeaconState, latest_shard_slot: Slot) -> Sequence[Slot]:
+    return [Slot(latest_shard_slot + x) for x in SHARD_BLOCK_OFFSETS if latest_shard_slot + x < state.slot]
 ```
 
 ### Predicates
@@ -613,14 +613,14 @@ def validate_attestation(state: BeaconState, attestation: Attestation) -> None:
         assert attestation.data.source == state.previous_justified_checkpoint
 
     shard = get_shard(state, attestation)
-    shard_start_slot = get_next_slot_for_shard(state, shard)
+    latest_shard_slot = get_latest_slot_for_shard(state, shard)
 
     # Type 1: on-time attestations
     if attestation.custody_bits_blocks != []:
         # Ensure on-time attestation
         assert data.slot + MIN_ATTESTATION_INCLUSION_DELAY == state.slot
         # Correct data root count
-        assert len(attestation.custody_bits_blocks) == len(get_offset_slots(state, shard_start_slot))
+        assert len(attestation.custody_bits_blocks) == len(get_offset_slots(state, latest_shard_slot))
         # Correct parent block root
         assert data.beacon_block_root == get_block_root_at_slot(state, get_previous_slot(state.slot))
     # Type 2: no shard transition, no custody bits  # TODO: could only allow for older attestations.
@@ -639,17 +639,17 @@ def validate_attestation(state: BeaconState, attestation: Attestation) -> None:
 ```python
 def apply_shard_transition(state: BeaconState, shard: Shard, transition: ShardTransition) -> None:
     # Slot the attestation starts counting from
-    start_slot = get_next_slot_for_shard(state, shard)
+    latest_slot = get_latest_slot_for_shard(state, shard)
 
     # Correct data root count
-    offset_slots = get_offset_slots(state, start_slot)
+    offset_slots = get_offset_slots(state, latest_slot)
     assert (
         len(transition.shard_data_roots)
         == len(transition.shard_states)
         == len(transition.shard_block_lengths)
         == len(offset_slots)
     )
-    assert transition.start_slot == start_slot
+    assert transition.start_slot == offset_slots[0]
 
     # Reconstruct shard headers
     headers = []
@@ -728,7 +728,7 @@ def process_crosslink_for_shard(state: BeaconState,
         increase_balance(state, beacon_proposer_index, proposer_reward)
         states_slots_lengths = zip(
             shard_transition.shard_states,
-            get_offset_slots(state, get_next_slot_for_shard(state, shard)),
+            get_offset_slots(state, get_latest_slot_for_shard(state, shard)),
             shard_transition.shard_block_lengths
         )
         for shard_state, slot, length in states_slots_lengths:
diff --git a/tests/core/pyspec/eth2spec/test/helpers/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
index fea4ea1f6..1e7c6300d 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/attestations.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
@@ -80,7 +80,7 @@ def convert_to_valid_on_time_attestation(spec, state, attestation, signed=False)
 
     next_state = state.copy()
     next_slot(spec, next_state)
-    offset_slots = spec.get_offset_slots(next_state, spec.get_next_slot_for_shard(next_state, shard))
+    offset_slots = spec.get_offset_slots(next_state, spec.get_latest_slot_for_shard(next_state, shard))
     for offset_slot in offset_slots:
         attestation.custody_bits_blocks.append(
             Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE]([0 for _ in attestation.aggregation_bits])
diff --git a/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
index 204458342..b97cc5d46 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
@@ -18,7 +18,7 @@ def get_valid_on_time_attestation(spec, state, index=None, signed=False):
 
     next_state = state.copy()
     next_slot(spec, next_state)
-    offset_slots = spec.get_offset_slots(next_state, spec.get_next_slot_for_shard(next_state, shard))
+    offset_slots = spec.get_offset_slots(next_state, spec.get_latest_slot_for_shard(next_state, shard))
     for offset_slot in offset_slots:
         attestation.custody_bits_blocks.append(
             Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE]([0 for _ in attestation.aggregation_bits])

From 92eef0e00b959c42d4e2602fc38f5fb34b681a19 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 9 Mar 2020 14:52:30 -0600
Subject: [PATCH 27/33] fix light client sig verification in phase 1

---
 specs/phase1/beacon-chain.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index 66d94bfe9..f1e025ed5 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -859,7 +859,7 @@ def process_light_client_signatures(state: BeaconState, block_body: BeaconBlockB
     slot = get_previous_slot(state.slot)
     signing_root = compute_signing_root(get_block_root_at_slot(state, slot), 
                                         get_domain(state, DOMAIN_LIGHT_CLIENT, compute_epoch_at_slot(slot)))
-    return bls.FastAggregateVerify(signer_pubkeys, signing_root, signature=block_body.light_client_signature)
+    assert bls.FastAggregateVerify(signer_pubkeys, signing_root, signature=block_body.light_client_signature)
 ```
 
 

From 071f6b51262551a7e40cd6b2b3113c92e8c60a2f Mon Sep 17 00:00:00 2001
From: Hsiao-Wei Wang <hwwang156@gmail.com>
Date: Wed, 25 Mar 2020 14:59:41 +0800
Subject: [PATCH 28/33] Gasprice rework: use `MIN_GASPRICE` as the initial
 gasprice and change `MIN_GASPRICE` to 8 gwei

---
 configs/mainnet.yaml         | 7 ++-----
 configs/minimal.yaml         | 6 ++----
 specs/phase1/beacon-chain.md | 2 +-
 specs/phase1/phase1-fork.md  | 3 +--
 4 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/configs/mainnet.yaml b/configs/mainnet.yaml
index 8306bb378..6d71cfa47 100644
--- a/configs/mainnet.yaml
+++ b/configs/mainnet.yaml
@@ -162,9 +162,6 @@ DOMAIN_CUSTODY_BIT_SLASHING: 0x83000000
 # ---------------------------------------------------------------
 PHASE_1_FORK_VERSION: 0x01000000
 INITIAL_ACTIVE_SHARDS: 64
-# Placeholder
-INITIAL_GASPRICE: 10
-
 
 # Phase 1: General
 # ---------------------------------------------------------------
@@ -190,8 +187,8 @@ SHARD_BLOCK_OFFSETS: [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
 MAX_SHARD_BLOCKS_PER_ATTESTATION: 12
 # 2**14 (= 16,384) Gwei
 MAX_GASPRICE: 16384
-# 2**5 (= 32) Gwei
-MIN_GASPRICE: 32
+# 2**3 (= 8) Gwei
+MIN_GASPRICE: 8
 #  2**3 (= 8)
 GASPRICE_ADJUSTMENT_COEFFICIENT: 8
 
diff --git a/configs/minimal.yaml b/configs/minimal.yaml
index e5d6ca308..9daf428b4 100644
--- a/configs/minimal.yaml
+++ b/configs/minimal.yaml
@@ -164,8 +164,6 @@ DOMAIN_CUSTODY_BIT_SLASHING: 0x83000000
 PHASE_1_FORK_VERSION: 0x01000001
 # [customized] reduced for testing
 INITIAL_ACTIVE_SHARDS: 4
-# Placeholder
-INITIAL_GASPRICE: 10
 
 
 # Phase 1: General
@@ -192,8 +190,8 @@ SHARD_BLOCK_OFFSETS: [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
 MAX_SHARD_BLOCKS_PER_ATTESTATION: 12
 # 2**14 (= 16,384) Gwei
 MAX_GASPRICE: 16384
-# 2**5 (= 32) Gwei
-MIN_GASPRICE: 32
+# 2**3 (= 8) Gwei
+MIN_GASPRICE: 8
 #  2**3 (= 8)
 GASPRICE_ADJUSTMENT_COEFFICIENT: 8
 
diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index e434e7eae..3db7f9537 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -101,7 +101,7 @@ Configuration is not namespaced. Instead it is strictly an extension;
 | `SHARD_BLOCK_OFFSETS` | `[1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]` | |
 | `MAX_SHARD_BLOCKS_PER_ATTESTATION` | `len(SHARD_BLOCK_OFFSETS)` | |
 | `MAX_GASPRICE` | `Gwei(2**14)` (= 16,384) | Gwei | |
-| `MIN_GASPRICE` | `Gwei(2**5)` (= 32) | Gwei | |
+| `MIN_GASPRICE` | `Gwei(2**3)` (= 8) | Gwei | |
 | `GASPRICE_ADJUSTMENT_COEFFICIENT` | `2**3` (= 8) | |
 | `DOMAIN_SHARD_PROPOSAL` | `DomainType('0x80000000')` | |
 | `DOMAIN_SHARD_COMMITTEE` | `DomainType('0x81000000')` | |
diff --git a/specs/phase1/phase1-fork.md b/specs/phase1/phase1-fork.md
index adb0cd236..173fceeb4 100644
--- a/specs/phase1/phase1-fork.md
+++ b/specs/phase1/phase1-fork.md
@@ -36,7 +36,6 @@ Warning: this configuration is not definitive.
 | - | - |
 | `PHASE_1_FORK_VERSION` | `Version('0x01000000')` |
 | `INITIAL_ACTIVE_SHARDS` | `2**6` (= 64) |
-| `INITIAL_GASPRICE` | `Gwei(10)` |
 
 ## Fork to Phase 1
 
@@ -102,7 +101,7 @@ def upgrade_to_phase1(pre: phase0.BeaconState) -> BeaconState:
         shard_states=List[ShardState, MAX_SHARDS](
             ShardState(
                 slot=pre.slot,
-                gasprice=INITIAL_GASPRICE,
+                gasprice=MIN_GASPRICE,
                 data=Root(),
                 latest_block_root=Root(),
             ) for i in range(INITIAL_ACTIVE_SHARDS)

From f82cdb7e68aab1b82b45d861a73bbf1858d59379 Mon Sep 17 00:00:00 2001
From: Hsiao-Wei Wang <hwwang156@gmail.com>
Date: Tue, 31 Mar 2020 18:21:33 +0800
Subject: [PATCH 29/33] beacon-chain.md: add `unpack_compact_validator` for
 `light-client-sync.md`

---
 specs/phase1/beacon-chain.md | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index e434e7eae..4c0473f2d 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -34,6 +34,7 @@
   - [Misc](#misc-1)
     - [`get_previous_slot`](#get_previous_slot)
     - [`pack_compact_validator`](#pack_compact_validator)
+    - [`unpack_compact_validator`](#unpack_compact_validator)
     - [`committee_to_compact_committee`](#committee_to_compact_committee)
     - [`compute_shard_from_committee_index`](#compute_shard_from_committee_index)
   - [Beacon state accessors](#beacon-state-accessors)
@@ -371,15 +372,29 @@ def get_previous_slot(slot: Slot) -> Slot:
 #### `pack_compact_validator`
 
 ```python
-def pack_compact_validator(index: int, slashed: bool, balance_in_increments: int) -> int:
+def pack_compact_validator(index: ValidatorIndex, slashed: bool, balance_in_increments: uint64) -> uint64:
     """
-    Creates a compact validator object representing index, slashed status, and compressed balance.
+    Create a compact validator object representing index, slashed status, and compressed balance.
     Takes as input balance-in-increments (// EFFECTIVE_BALANCE_INCREMENT) to preserve symmetry with
     the unpacking function.
     """
     return (index << 16) + (slashed << 15) + balance_in_increments
 ```
 
+#### `unpack_compact_validator`
+
+```python
+def unpack_compact_validator(compact_validator: uint64) -> Tuple[ValidatorIndex, bool, uint64]:
+    """
+    Return validator index, slashed, balance // EFFECTIVE_BALANCE_INCREMENT
+    """
+    return (
+        ValidatorIndex(compact_validator >> 16),
+        bool((compact_validator >> 15) % 2),
+        compact_validator & (2**15 - 1),
+    )
+```
+
 #### `committee_to_compact_committee`
 
 ```python

From 613f368c0007a9ca4671793039874f3ecc299f58 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 1 Apr 2020 12:20:32 -0600
Subject: [PATCH 30/33] fix call to get_beacon_committee in
 process_crosslink_for_shard

---
 specs/phase1/beacon-chain.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index 9207e3a08..9c0cd0a6c 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -709,11 +709,12 @@ def apply_shard_transition(state: BeaconState, shard: Shard, transition: ShardTr
 
 ```python
 def process_crosslink_for_shard(state: BeaconState,
-                                shard: Shard,
+                                committee_index: CommitteeIndex,
                                 shard_transition: ShardTransition,
                                 attestations: Sequence[Attestation]) -> Root:
-    committee = get_beacon_committee(state, get_current_epoch(state), shard)
+    committee = get_beacon_committee(state, state.slot, committee_index)
     online_indices = get_online_validator_indices(state)
+    shard = compute_shard_from_committee_index(state, committee_index, state.slot)
 
     # Loop over all shard transition roots
     shard_transition_roots = set([a.data.shard_transition_root for a in attestations])
@@ -775,7 +776,7 @@ def process_crosslinks(state: BeaconState,
             if attestation.data.index == committee_index and attestation.data.slot == state.slot
         ]
         shard_transition = shard_transitions[shard]
-        winning_root = process_crosslink_for_shard(state, shard, shard_transition, shard_attestations)
+        winning_root = process_crosslink_for_shard(state, committee_index, shard_transition, shard_attestations)
         if winning_root != Root():
             # Mark relevant pending attestations as creating a successful crosslink
             for pending_attestation in state.current_epoch_attestations:

From f2c2da95ed871735d35ef757641f92bd1d31133a Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Fri, 3 Apr 2020 09:19:56 -0600
Subject: [PATCH 31/33] add compute_offset_slots

---
 specs/phase1/beacon-chain.md                  | 19 +++++++++++--------
 .../eth2spec/test/helpers/attestations.py     |  7 ++-----
 .../test/helpers/phase1/attestations.py       |  5 +----
 3 files changed, 14 insertions(+), 17 deletions(-)

diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index 9c0cd0a6c..5079ec5c5 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -517,11 +517,18 @@ def get_latest_slot_for_shard(state: BeaconState, shard: Shard) -> Slot:
     return state.shard_states[shard].slot
 ```
 
+#### `compute_offset_slots`
+
+```python
+def compute_offset_slots(start_slot: Slot, end_slot: Slot) -> Sequence[Slot]:
+    return [Slot(start_slot + x) for x in SHARD_BLOCK_OFFSETS if start_slot + x < end_slot]
+```
+
 #### `get_offset_slots`
 
 ```python
-def get_offset_slots(state: BeaconState, latest_shard_slot: Slot) -> Sequence[Slot]:
-    return [Slot(latest_shard_slot + x) for x in SHARD_BLOCK_OFFSETS if latest_shard_slot + x < state.slot]
+def get_offset_slots(state: BeaconState, shard: Shard) -> Sequence[Slot]:
+    return compute_offset_slots(state.shard_states[shard].slot, state.slot)
 ```
 
 ### Predicates
@@ -630,14 +637,13 @@ def validate_attestation(state: BeaconState, attestation: Attestation) -> None:
         assert attestation.data.source == state.previous_justified_checkpoint
 
     shard = get_shard(state, attestation)
-    latest_shard_slot = get_latest_slot_for_shard(state, shard)
 
     # Type 1: on-time attestations
     if attestation.custody_bits_blocks != []:
         # Ensure on-time attestation
         assert data.slot + MIN_ATTESTATION_INCLUSION_DELAY == state.slot
         # Correct data root count
-        assert len(attestation.custody_bits_blocks) == len(get_offset_slots(state, latest_shard_slot))
+        assert len(attestation.custody_bits_blocks) == len(get_offset_slots(state, shard))
         # Correct parent block root
         assert data.beacon_block_root == get_block_root_at_slot(state, get_previous_slot(state.slot))
     # Type 2: no shard transition, no custody bits  # TODO: could only allow for older attestations.
@@ -655,11 +661,8 @@ def validate_attestation(state: BeaconState, attestation: Attestation) -> None:
 
 ```python
 def apply_shard_transition(state: BeaconState, shard: Shard, transition: ShardTransition) -> None:
-    # Slot the attestation starts counting from
-    latest_slot = get_latest_slot_for_shard(state, shard)
-
     # Correct data root count
-    offset_slots = get_offset_slots(state, latest_slot)
+    offset_slots = get_offset_slots(state, shard)
     assert (
         len(transition.shard_data_roots)
         == len(transition.shard_states)
diff --git a/tests/core/pyspec/eth2spec/test/helpers/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
index af989a9c0..7daaf159e 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/attestations.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/attestations.py
@@ -1,7 +1,7 @@
 from typing import List
 
 from eth2spec.test.context import expect_assertion_error
-from eth2spec.test.helpers.state import next_slot, state_transition_and_sign_block
+from eth2spec.test.helpers.state import state_transition_and_sign_block
 from eth2spec.test.helpers.block import build_empty_block_for_next_slot
 from eth2spec.test.helpers.keys import privkeys
 from eth2spec.utils import bls
@@ -77,10 +77,7 @@ def build_attestation_data(spec, state, slot, index):
 
 def convert_to_valid_on_time_attestation(spec, state, attestation, signed=False):
     shard = spec.get_shard(state, attestation)
-
-    next_state = state.copy()
-    next_slot(spec, next_state)
-    offset_slots = spec.get_offset_slots(next_state, spec.get_latest_slot_for_shard(next_state, shard))
+    offset_slots = spec.compute_offset_slots(spec.get_latest_slot_for_shard(state, shard), state.slot + 1)
     for offset_slot in offset_slots:
         attestation.custody_bits_blocks.append(
             Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE]([0 for _ in attestation.aggregation_bits])
diff --git a/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
index b97cc5d46..676908f85 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
@@ -3,7 +3,6 @@ from eth2spec.utils import bls
 
 from eth2spec.test.helpers.keys import privkeys
 import eth2spec.test.helpers.attestations as phase0_attestations
-from eth2spec.test.helpers.state import next_slot
 
 
 def get_valid_on_time_attestation(spec, state, index=None, signed=False):
@@ -15,10 +14,8 @@ def get_valid_on_time_attestation(spec, state, index=None, signed=False):
 
     attestation = phase0_attestations.get_valid_attestation(spec, state, state.slot, index, False)
     shard = spec.get_shard(state, attestation)
+    offset_slots = spec.compute_offset_slots(spec.get_latest_slot_for_shard(state, shard), state.slot + 1)
 
-    next_state = state.copy()
-    next_slot(spec, next_state)
-    offset_slots = spec.get_offset_slots(next_state, spec.get_latest_slot_for_shard(next_state, shard))
     for offset_slot in offset_slots:
         attestation.custody_bits_blocks.append(
             Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE]([0 for _ in attestation.aggregation_bits])

From 246b46771e7b180cfdfd59b6c3812e9f44f6a60e Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Fri, 3 Apr 2020 09:46:22 -0600
Subject: [PATCH 32/33] address @hwwhww feedback

---
 specs/phase1/beacon-chain.md                  | 32 ++++++++++++++-----
 .../test/helpers/phase1/attestations.py       |  2 +-
 .../test_process_rewards_and_penalties.py     | 17 +++++-----
 3 files changed, 33 insertions(+), 18 deletions(-)

diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index 5079ec5c5..a5c4db859 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -48,8 +48,10 @@
     - [`get_start_shard`](#get_start_shard)
     - [`get_shard`](#get_shard)
     - [`get_latest_slot_for_shard`](#get_latest_slot_for_shard)
+    - [`compute_offset_slots`](#compute_offset_slots)
     - [`get_offset_slots`](#get_offset_slots)
   - [Predicates](#predicates)
+    - [`is_winning_attestation`](#is_winning_attestation)
     - [Updated `is_valid_indexed_attestation`](#updated-is_valid_indexed_attestation)
   - [Block processing](#block-processing)
     - [Operations](#operations)
@@ -533,6 +535,24 @@ def get_offset_slots(state: BeaconState, shard: Shard) -> Sequence[Slot]:
 
 ### Predicates
 
+#### `is_winning_attestation`
+
+```python
+def is_winning_attestation(state: BeaconState,
+                           attestation: PendingAttestation,
+                           committee_index: CommitteeIndex,
+                           winning_root: Root) -> bool:
+    """
+    Check if ``attestation`` helped contribute to the successful crosslink of
+    ``winning_root`` formed by ``committee_index`` committee at the current slot.
+    """
+    return (
+        attestation.slot == state.slot
+        and attestation.data.index == committee_index
+        and attestation.data.shard_transition_root == winning_root
+    )
+```
+
 #### Updated `is_valid_indexed_attestation`
 
 Note that this replaces the Phase 0 `is_valid_indexed_attestation`.
@@ -638,7 +658,7 @@ def validate_attestation(state: BeaconState, attestation: Attestation) -> None:
 
     shard = get_shard(state, attestation)
 
-    # Type 1: on-time attestations
+    # Type 1: on-time attestations, the custody bits should be non-empty.
     if attestation.custody_bits_blocks != []:
         # Ensure on-time attestation
         assert data.slot + MIN_ATTESTATION_INCLUSION_DELAY == state.slot
@@ -646,7 +666,7 @@ def validate_attestation(state: BeaconState, attestation: Attestation) -> None:
         assert len(attestation.custody_bits_blocks) == len(get_offset_slots(state, shard))
         # Correct parent block root
         assert data.beacon_block_root == get_block_root_at_slot(state, get_previous_slot(state.slot))
-    # Type 2: no shard transition, no custody bits  # TODO: could only allow for older attestations.
+    # Type 2: no shard transition, no custody bits
     else:
         # Ensure delayed attestation
         assert data.slot + MIN_ATTESTATION_INCLUSION_DELAY < state.slot  
@@ -783,11 +803,7 @@ def process_crosslinks(state: BeaconState,
         if winning_root != Root():
             # Mark relevant pending attestations as creating a successful crosslink
             for pending_attestation in state.current_epoch_attestations:
-                if (
-                    pending_attestation.slot == state.slot and pending_attestation
-                    and pending_attestation.data.index == committee_index
-                    and pending_attestation.data.shard_transition_root == winning_root
-                ):
+                if is_winning_attestation(state, pending_attestation, committee_index, winning_root):
                     pending_attestation.crosslink_success = True
 ```
 
@@ -801,8 +817,8 @@ def process_attestation(state: BeaconState, attestation: Attestation) -> None:
         aggregation_bits=attestation.aggregation_bits,
         data=attestation.data,
         inclusion_delay=state.slot - attestation.data.slot,
-        crosslink_success=False,  # To be filled in during process_crosslinks
         proposer_index=get_beacon_proposer_index(state),
+        crosslink_success=False,  # To be filled in during process_crosslinks
     )
     if attestation.data.target.epoch == get_current_epoch(state):
         state.current_epoch_attestations.append(pending_attestation)
diff --git a/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
index 676908f85..0e16e1fac 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/phase1/attestations.py
@@ -16,7 +16,7 @@ def get_valid_on_time_attestation(spec, state, index=None, signed=False):
     shard = spec.get_shard(state, attestation)
     offset_slots = spec.compute_offset_slots(spec.get_latest_slot_for_shard(state, shard), state.slot + 1)
 
-    for offset_slot in offset_slots:
+    for _ in offset_slots:
         attestation.custody_bits_blocks.append(
             Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE]([0 for _ in attestation.aggregation_bits])
         )
diff --git a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py
index 317c97149..af695fe69 100644
--- a/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py
+++ b/tests/core/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py
@@ -22,13 +22,16 @@ def run_process_rewards_and_penalties(spec, state):
 
 
 def prepare_state_with_full_attestations(spec, state, empty=False):
+    # Go to start of next epoch to ensure can have full participation
+    next_epoch(spec, state)
+
     start_slot = state.slot
     start_epoch = spec.get_current_epoch(state)
-    next_start_epoch = spec.compute_start_slot_at_epoch(start_epoch + 1)
+    next_epoch_start_slot = spec.compute_start_slot_at_epoch(start_epoch + 1)
     attestations = []
-    for slot in range(spec.SLOTS_PER_EPOCH + spec.MIN_ATTESTATION_INCLUSION_DELAY):
+    for _ in range(spec.SLOTS_PER_EPOCH + spec.MIN_ATTESTATION_INCLUSION_DELAY):
         # create an attestation for each index in each slot in epoch
-        if state.slot < next_start_epoch:
+        if state.slot < next_epoch_start_slot:
             for committee_index in range(spec.get_committee_count_at_slot(state, state.slot)):
                 attestation = get_valid_attestation(spec, state, index=committee_index, empty=empty, signed=True)
                 attestations.append(attestation)
@@ -39,7 +42,7 @@ def prepare_state_with_full_attestations(spec, state, empty=False):
             add_attestations_to_state(spec, state, include_attestations, state.slot)
         next_slot(spec, state)
 
-    assert spec.compute_epoch_at_slot(state.slot) == start_epoch + 1
+    assert state.slot == next_epoch_start_slot + spec.MIN_ATTESTATION_INCLUSION_DELAY
     assert len(state.previous_epoch_attestations) == len(attestations)
 
     return attestations
@@ -87,8 +90,6 @@ def test_genesis_epoch_full_attestations_no_rewards(spec, state):
 @with_all_phases
 @spec_state_test
 def test_full_attestations(spec, state):
-    # Go to start of next epoch to ensure can have full participation
-    next_epoch(spec, state)
     attestations = prepare_state_with_full_attestations(spec, state)
 
     pre_state = state.copy()
@@ -132,8 +133,6 @@ def test_full_attestations_random_incorrect_fields(spec, state):
 @with_custom_state(balances_fn=misc_balances, threshold_fn=lambda spec: spec.MAX_EFFECTIVE_BALANCE // 2)
 @single_phase
 def test_full_attestations_misc_balances(spec, state):
-    # Go to start of next epoch to ensure can have full participation
-    next_epoch(spec, state)
     attestations = prepare_state_with_full_attestations(spec, state)
 
     pre_state = state.copy()
@@ -178,6 +177,7 @@ def test_full_attestations_one_validaor_one_gwei(spec, state):
 @with_all_phases
 @spec_state_test
 def test_no_attestations_all_penalties(spec, state):
+    # Move to next epoch to ensure rewards/penalties are processed
     next_epoch(spec, state)
     pre_state = state.copy()
 
@@ -254,7 +254,6 @@ def test_attestations_some_slashed(spec, state):
     for i in range(spec.MIN_PER_EPOCH_CHURN_LIMIT):
         spec.slash_validator(state, attesting_indices_before_slashings[i])
 
-    assert spec.compute_epoch_at_slot(state.slot) == spec.GENESIS_EPOCH + 1
     assert len(state.previous_epoch_attestations) == len(attestations)
 
     pre_state = state.copy()

From e86c5ef41dabdb7e688d8789478d03db6c10fd26 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Fri, 3 Apr 2020 10:29:35 -0600
Subject: [PATCH 33/33] final PR nitpicks

---
 specs/phase1/beacon-chain.md | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/specs/phase1/beacon-chain.md b/specs/phase1/beacon-chain.md
index a5c4db859..596b3818f 100644
--- a/specs/phase1/beacon-chain.md
+++ b/specs/phase1/beacon-chain.md
@@ -37,6 +37,7 @@
     - [`unpack_compact_validator`](#unpack_compact_validator)
     - [`committee_to_compact_committee`](#committee_to_compact_committee)
     - [`compute_shard_from_committee_index`](#compute_shard_from_committee_index)
+    - [`compute_offset_slots`](#compute_offset_slots)
   - [Beacon state accessors](#beacon-state-accessors)
     - [`get_active_shard_count`](#get_active_shard_count)
     - [`get_online_validator_indices`](#get_online_validator_indices)
@@ -48,7 +49,6 @@
     - [`get_start_shard`](#get_start_shard)
     - [`get_shard`](#get_shard)
     - [`get_latest_slot_for_shard`](#get_latest_slot_for_shard)
-    - [`compute_offset_slots`](#compute_offset_slots)
     - [`get_offset_slots`](#get_offset_slots)
   - [Predicates](#predicates)
     - [`is_winning_attestation`](#is_winning_attestation)
@@ -421,6 +421,16 @@ def compute_shard_from_committee_index(state: BeaconState, index: CommitteeIndex
     return Shard((index + get_start_shard(state, slot)) % active_shards)
 ```
 
+#### `compute_offset_slots`
+
+```python
+def compute_offset_slots(start_slot: Slot, end_slot: Slot) -> Sequence[Slot]:
+    """
+    Return the offset slots that are greater than ``start_slot`` and less than ``end_slot``.
+    """
+    return [Slot(start_slot + x) for x in SHARD_BLOCK_OFFSETS if start_slot + x < end_slot]
+```
+
 ### Beacon state accessors
 
 #### `get_active_shard_count`
@@ -519,13 +529,6 @@ def get_latest_slot_for_shard(state: BeaconState, shard: Shard) -> Slot:
     return state.shard_states[shard].slot
 ```
 
-#### `compute_offset_slots`
-
-```python
-def compute_offset_slots(start_slot: Slot, end_slot: Slot) -> Sequence[Slot]:
-    return [Slot(start_slot + x) for x in SHARD_BLOCK_OFFSETS if start_slot + x < end_slot]
-```
-
 #### `get_offset_slots`
 
 ```python