From c5143ccefaddd9929bfb68401c6c00e1afa75e6d Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Thu, 20 Jun 2019 14:48:10 -0600
Subject: [PATCH 1/9] modify fork choice to utilize epochs as first class
 citizens

---
 specs/core/0_fork-choice.md | 69 ++++++++++++++++++++++++++++++-------
 1 file changed, 57 insertions(+), 12 deletions(-)

diff --git a/specs/core/0_fork-choice.md b/specs/core/0_fork-choice.md
index 6b7e4bdbea..3bcb6b8894 100644
--- a/specs/core/0_fork-choice.md
+++ b/specs/core/0_fork-choice.md
@@ -63,17 +63,30 @@ class Target(object):
     root: Hash
 ```
 
+#### `RootSlot`
+
+```python
+@dataclass
+class RootSlot(object):
+    slot: Slot
+    root: Hash
+```
+
+
+
 #### `Store`
 
 ```python
 @dataclass
 class Store(object):
     blocks: Dict[Hash, BeaconBlock] = field(default_factory=dict)
-    states: Dict[Hash, BeaconState] = field(default_factory=dict)
+    states: Dict[RootSlot, BeaconState] = field(default_factory=dict)
     time: int = 0
     latest_targets: Dict[ValidatorIndex, Target] = field(default_factory=dict)
     justified_root: Hash = ZERO_HASH
+    justified_epoch: Epoch = 0
     finalized_root: Hash = ZERO_HASH
+    finalized_epoch: Epoch = 0
 ```
 
 #### `get_genesis_store`
@@ -98,8 +111,8 @@ def get_ancestor(store: Store, root: Hash, slot: Slot) -> Hash:
 
 ```python
 def get_latest_attesting_balance(store: Store, root: Hash) -> Gwei:
-    state = store.states[store.justified_root]
-    active_indices = get_active_validator_indices(state.validator_registry, slot_to_epoch(state.slot))
+    state = store.states[RootSlot(store.justified_root, get_epoch_start_slot(store.justified_epoch)]
+    active_indices = get_active_validator_indices(state.validator_registry, get_current_epoch(state))
     return Gwei(sum(
         state.validator_registry[i].effective_balance for i in active_indices
         if get_ancestor(store, store.latest_targets[i].root, store.blocks[root].slot) == root
@@ -112,8 +125,12 @@ def get_latest_attesting_balance(store: Store, root: Hash) -> Gwei:
 def get_head(store: Store) -> Hash:
     # Execute the LMD-GHOST fork choice
     head = store.justified_root
+    justified_slot = get_epoch_start_slot(store.justified_epoch)
     while True:
-        children = [root for root in store.blocks.keys() if store.blocks[root].parent_root == head]
+        children = [
+            root for root in store.blocks.keys()
+            if store.blocks[root].parent_root == head and store.blocks[root].slot > justified_slot
+        ]
         if len(children) == 0:
             return head
         # Sort by latest attesting balance with ties broken lexicographically
@@ -137,30 +154,58 @@ def on_block(store: Store, block: BeaconBlock) -> None:
     store.blocks[signing_root(block)] = block
     # Check block is a descendant of the finalized block
     assert get_ancestor(store, signing_root(block), store.blocks[store.finalized_root].slot) == store.finalized_root
+    # Check that block is later than the finalized epoch slot
+    assert blocks.slot > get_epoch_start_slot(store.finalized_epoch)
     # Check block slot against Unix time
     pre_state = deepcopy(store.states[block.parent_root])
     assert store.time >= pre_state.genesis_time + block.slot * SECONDS_PER_SLOT
     # Check the block is valid and compute the post-state
     state = state_transition(pre_state, block)
-    # Add new state to the store
-    store.states[signing_root(block)] = state
-    # Update justified block root
-    if state.current_justified_epoch > slot_to_epoch(store.blocks[store.justified_root].slot):
+    # Add new state for this block to the store
+    store.states[RootSlot(signing_root(block), block.slot)] = state
+    # Update justified block root and epoch
+    previous_justified_epoch = store.justified_epoch
+    justified_root_slot = None
+    if state.current_justified_epoch > store.justified_epoch:
         store.justified_root = state.current_justified_root
-    elif state.previous_justified_epoch > slot_to_epoch(store.blocks[store.justified_root].slot):
+        state.justified_epoch = state.current_justified_epoch
+    elif state.previous_justified_epoch > store.justified_epoch:
         store.justified_root = state.previous_justified_root
-    # Update finalized block root
-    if state.finalized_epoch > slot_to_epoch(store.blocks[store.finalized_root].slot):
+        state.justified_epoch = state.previous_justified_epoch
+
+    # Store justified state
+    if previous_justified_epoch != store.justified_epoch:
+        justified_slot = get_epoch_start_slot(store.justified_epoch)
+        justified_root_slot = RootSlot(store.justified_root, justified_slot)
+        if justified_root_slot not in store.states:
+            base_state = store.states[RootSlot(store.justified_root, store.blocks[store.justified_root].slot)]
+            store.states[justified_root_slot] = process_slots(deepcopy(base_state), justified_slot)
+
+    # Update finalized block root and epoch, and store finalized state
+    if state.finalized_epoch > state.finalized_epoch:
         store.finalized_root = state.finalized_root
+        store.finalized_epoch = state.finalized_epoch
+        finalized_slot = get_epoch_start_slot(store.finalized_epoch)
+        finalized_root_slot = RootSlot(store.finalized_root, finalized_slot)
+        if finalized_root_slot not in store.states:
+            base_state = store.states[RootSlot(store.finalized_root, store.blocks[store.finalized_root].slot)]
+            store.states[finalized_root_slot] = process_slots(deepcopy(base_state), finalized_slot)
 ```
 
 #### `on_attestation`
 
 ```python
 def on_attestation(store: Store, attestation: Attestation) -> None:
-    state = store.states[get_head(store)]
+    # cannot calculate the current shuffling if have not seen the target
+    assert attestation.data.target_root in store.blocks
+
+    # get state at the `target_root`/`target_epoch` to validate attestation and calculate the committees
+    state = store.states[(attestation.data.target_root, get_epoch_start_slot(attestation.data.target_epoch))]
+
     indexed_attestation = convert_to_indexed(state, attestation)
     validate_indexed_attestation(state, indexed_attestation)
+
+    # update latest targets
     for i in indexed_attestation.custody_bit_0_indices + indexed_attestation.custody_bit_1_indices:
         if i not in store.latest_targets or attestation.data.target_epoch > store.latest_targets[i].epoch:
             store.latest_targets[i] = Target(attestation.data.target_epoch, attestation.data.target_root)

From fb9a5f0bc5e2358fbb2a57f3324b83ca2f82ed07 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Thu, 20 Jun 2019 14:57:53 -0600
Subject: [PATCH 2/9] one more rootslot fix

---
 specs/core/0_fork-choice.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/specs/core/0_fork-choice.md b/specs/core/0_fork-choice.md
index 3bcb6b8894..668b207143 100644
--- a/specs/core/0_fork-choice.md
+++ b/specs/core/0_fork-choice.md
@@ -157,7 +157,8 @@ def on_block(store: Store, block: BeaconBlock) -> None:
     # Check that block is later than the finalized epoch slot
     assert blocks.slot > get_epoch_start_slot(store.finalized_epoch)
     # Check block slot against Unix time
-    pre_state = deepcopy(store.states[block.parent_root])
+    parent_block = store.blocks[block.parent_root]
+    pre_state = deepcopy(store.states[RootSlot(signing_root(parent_block), parent_block.slot)])
     assert store.time >= pre_state.genesis_time + block.slot * SECONDS_PER_SLOT
     # Check the block is valid and compute the post-state
     state = state_transition(pre_state, block)

From 1b66a1a2bd297d33f666deede5b403388197073a Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Fri, 21 Jun 2019 12:55:55 -0600
Subject: [PATCH 3/9] rework forkchoice to use Checkpoints

---
 specs/core/0_fork-choice.md | 106 +++++++++++++++---------------------
 1 file changed, 43 insertions(+), 63 deletions(-)

diff --git a/specs/core/0_fork-choice.md b/specs/core/0_fork-choice.md
index ee318412df..1755c6df35 100644
--- a/specs/core/0_fork-choice.md
+++ b/specs/core/0_fork-choice.md
@@ -12,7 +12,7 @@
         - [Time parameters](#time-parameters)
     - [Fork choice](#fork-choice)
         - [Helpers](#helpers)
-            - [`Target`](#target)
+            - [`Checkpoint`](#checkpoint)
             - [`Store`](#store)
             - [`get_genesis_store`](#get_genesis_store)
             - [`get_ancestor`](#get_ancestor)
@@ -55,39 +55,27 @@ The head block root associated with a `store` is defined as `get_head(store)`. A
 
 ### Helpers
 
-#### `Target`
+#### `Checkpoint`
 
 ```python
 @dataclass
-class Target(object):
+class Checkpoint(object):
     epoch: Epoch
     root: Hash
 ```
 
-#### `RootSlot`
-
-```python
-@dataclass
-class RootSlot(object):
-    slot: Slot
-    root: Hash
-```
-
-
-
 #### `Store`
 
 ```python
 @dataclass
 class Store(object):
     blocks: Dict[Hash, BeaconBlock] = field(default_factory=dict)
-    states: Dict[RootSlot, BeaconState] = field(default_factory=dict)
-    time: int = 0
-    latest_targets: Dict[ValidatorIndex, Target] = field(default_factory=dict)
-    justified_root: Hash = ZERO_HASH
-    justified_epoch: Epoch = 0
-    finalized_root: Hash = ZERO_HASH
-    finalized_epoch: Epoch = 0
+    block_states: Dict[Hash, BeaconState] = field(default_factory=dict)
+    checkpoint_states: Dict[Checkpoint, BeaconState] = field(default_factory=dict)
+    time: int
+    latest_targets: Dict[ValidatorIndex, Checkpoint] = field(default_factory=dict)
+    justified_checkpoint: Checkpoint
+    finalized_checkpoint: Checkpoint
 ```
 
 #### `get_genesis_store`
@@ -96,12 +84,15 @@ class Store(object):
 def get_genesis_store(genesis_state: BeaconState) -> Store:
     genesis_block = BeaconBlock(state_root=hash_tree_root(genesis_state))
     root = signing_root(genesis_block)
+    justified_checkpoint = Checkpoint(GENESIS_EPOCH, root)
+    finalized_checkpoint = Checkpoint(GENESIS_EPOCH, root)
     return Store(
         blocks={root: genesis_block},
-        states={root: genesis_state},
+        block_states={root: genesis_state},
+        checkpoint_states={justified_checkpoint: genesis_state.copy()},
         time=genesis_state.genesis_time,
-        justified_root=root,
-        finalized_root=root,
+        justified_checkpoint=justified_checkpoint,
+        finalized_checkpoint=finalized_checkpoint,
     )
 ```
 
@@ -118,7 +109,7 @@ def get_ancestor(store: Store, root: Hash, slot: Slot) -> Hash:
 
 ```python
 def get_latest_attesting_balance(store: Store, root: Hash) -> Gwei:
-    state = store.states[RootSlot(store.justified_root, get_epoch_start_slot(store.justified_epoch)]
+    state = store.checkpoint_states[store.justified_checkpoint]
     active_indices = get_active_validator_indices(state.validator_registry, get_current_epoch(state))
     return Gwei(sum(
         state.validator_registry[i].effective_balance for i in active_indices
@@ -131,8 +122,8 @@ def get_latest_attesting_balance(store: Store, root: Hash) -> Gwei:
 ```python
 def get_head(store: Store) -> Hash:
     # Execute the LMD-GHOST fork choice
-    head = store.justified_root
-    justified_slot = get_epoch_start_slot(store.justified_epoch)
+    head = store.justified_checkpoint.root
+    justified_slot = get_epoch_start_slot(store.justified_checkpoint.epoch)
     while True:
         children = [
             root for root in store.blocks.keys()
@@ -159,63 +150,52 @@ def on_tick(store: Store, time: int) -> None:
 def on_block(store: Store, block: BeaconBlock) -> None:
     # Make a copy of the state to avoid mutability issues
     parent_block = store.blocks[block.parent_root]
-    pre_state = store.states[RootSlot(signing_root(parent_block), parent_block.slot)].copy()
+    pre_state = store.block_states[parent_block.root].copy()
     # Blocks cannot be in the future. If they are, their consideration must be delayed until the are in the past.
     assert store.time >= pre_state.genesis_time + block.slot * SECONDS_PER_SLOT
     # Add new block to the store
     store.blocks[signing_root(block)] = block
     # Check block is a descendant of the finalized block
-    assert get_ancestor(store, signing_root(block), store.blocks[store.finalized_root].slot) == store.finalized_root
+    assert get_ancestor(store, signing_root(block), store.blocks[get_epoch_start_slot(store.finalized_checkpoint)].slot) == store.finalized_checkpoint.root
     # Check that block is later than the finalized epoch slot
-    assert blocks.slot > get_epoch_start_slot(store.finalized_epoch)
+    assert block.slot > get_epoch_start_slot(store.finalized_checkpoint.epoch)
     # Check the block is valid and compute the post-state
     state = state_transition(pre_state, block)
     # Add new state for this block to the store
-    store.states[RootSlot(signing_root(block), block.slot)] = state
-    # Update justified block root and epoch
-    previous_justified_epoch = store.justified_epoch
-    justified_root_slot = None
-    if state.current_justified_epoch > store.justified_epoch:
-        store.justified_root = state.current_justified_root
-        state.justified_epoch = state.current_justified_epoch
+    store.block_states[signing_root(block)] = state
+
+    # Update justified checkpoint
+    if state.current_justified_epoch > store.justified_checkpoint.epoch:
+        store.justified_checkpoint = Checkpoint(state.current_justified_epoch, state.current_justified_root)
     elif state.previous_justified_epoch > store.justified_epoch:
-        store.justified_root = state.previous_justified_root
-        state.justified_epoch = state.previous_justified_epoch
-
-    # Store justified state
-    if previous_justified_epoch != store.justified_epoch:
-        justified_slot = get_epoch_start_slot(store.justified_epoch)
-        justified_root_slot = RootSlot(store.justified_root, justified_slot)
-        if justified_root_slot not in store.states:
-            base_state = store.states[RootSlot(store.justified_root, store.blocks[store.justified_root].slot)]
-            store.states[justified_root_slot] = process_slots(deepcopy(base_state), justified_slot)
-
-    # Update finalized block root and epoch, and store finalized state
+        store.justified_checkpoint = Checkpoint(state.previous_justified_epoch, state.previous_justified_root)
+
+    # Update finalized checkpoint
     if state.finalized_epoch > state.finalized_epoch:
-        store.finalized_root = state.finalized_root
-        store.finalized_epoch = state.finalized_epoch
-        finalized_slot = get_epoch_start_slot(store.finalized_epoch)
-        finalized_root_slot = RootSlot(store.finalized_root, finalized_slot)
-        if finalized_root_slot not in store.states:
-            base_state = store.states[RootSlot(store.finalized_root, store.blocks[store.finalized_root].slot)]
-            store.states[finalized_root_slot] = process_slots(deepcopy(base_state), finalized_slot)
+        store.finalized_checkpoint = Checkpoint(state.finalized_epoch, state.finalized_root)
 ```
 
 #### `on_attestation`
 
 ```python
 def on_attestation(store: Store, attestation: Attestation) -> None:
-    # cannot calculate the current shuffling if have not seen the target
-    assert attestation.data.target_root in store.blocks
+    target_checkpoint = Checkpoint(attestation.data.target_epoch, attestation.data, target_root)
+
+    # Cannot calculate the current shuffling if have not seen the target
+    assert target_checkpoint.root in store.blocks
 
-    # get state at the `target_root`/`target_epoch` to validate attestation and calculate the committees
-    state = store.states[(attestation.data.target_root, get_epoch_start_slot(attestation.data.target_epoch))]
+    # Store target checkpoint state if not yet seen
+    if target_checkpoint not in store.checkpoint_states:
+        base_state = store.block_states[target_checkpoint.root].copy()
+        store.checkpoint_states[target_checkpoint] = process_slots(base_state, get_epoch_start_slot(target_checkpoint.epoch))
 
+    # Get state at the `target_checkpoint` to validate attestation and calculate the committees
+    state = store.checkpoint_states[target_checkpoint]
     indexed_attestation = convert_to_indexed(state, attestation)
     validate_indexed_attestation(state, indexed_attestation)
 
-    # update latest targets
+    # Update latest targets
     for i in indexed_attestation.custody_bit_0_indices + indexed_attestation.custody_bit_1_indices:
-        if i not in store.latest_targets or attestation.data.target_epoch > store.latest_targets[i].epoch:
-            store.latest_targets[i] = Target(attestation.data.target_epoch, attestation.data.target_root)
+        if i not in store.latest_targets or target_checkpoint.epoch > store.latest_targets[i].epoch:
+            store.latest_targets[i] = target_checkpoint
 ```

From 0e362d36b1eda660d013d32002acf7fce0c8ff91 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 24 Jun 2019 17:18:22 -0600
Subject: [PATCH 4/9] pr feedback

---
 specs/core/0_fork-choice.md | 30 +++++++++++++++++++-----------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/specs/core/0_fork-choice.md b/specs/core/0_fork-choice.md
index 1755c6df35..1818de6c4d 100644
--- a/specs/core/0_fork-choice.md
+++ b/specs/core/0_fork-choice.md
@@ -179,23 +179,31 @@ def on_block(store: Store, block: BeaconBlock) -> None:
 
 ```python
 def on_attestation(store: Store, attestation: Attestation) -> None:
-    target_checkpoint = Checkpoint(attestation.data.target_epoch, attestation.data, target_root)
+    target = Checkpoint(attestation.data.target_epoch, attestation.data.target_root)
 
     # Cannot calculate the current shuffling if have not seen the target
-    assert target_checkpoint.root in store.blocks
+    assert target.root in store.blocks
+
+    # Attestations cannot be from future epochs. If they are, their consideration must be delayed until the are in the past.
+    assert store.time >= pre_state.genesis_time + get_epoch_start_slot(target.epoch) * SECONDS_PER_SLOT
 
     # Store target checkpoint state if not yet seen
-    if target_checkpoint not in store.checkpoint_states:
-        base_state = store.block_states[target_checkpoint.root].copy()
-        store.checkpoint_states[target_checkpoint] = process_slots(base_state, get_epoch_start_slot(target_checkpoint.epoch))
+    if target not in store.checkpoint_states:
+        base_state = store.block_states[target.root].copy()
+        store.checkpoint_states[target] = process_slots(base_state, get_epoch_start_slot(target.epoch))
+    target_state = store.checkpoint_states[target]
+
+    # Attestations can only affect the fork choice of subsequent slots.
+    # Delay consideration in the fork choice until their slot is in the past.
+    attestation_slot = get_attestation_data_slot(target_state, attestation.data)
+    assert store.time >= (attestation_slot + 1) * SECONDS_PER_SLOT
 
-    # Get state at the `target_checkpoint` to validate attestation and calculate the committees
-    state = store.checkpoint_states[target_checkpoint]
-    indexed_attestation = convert_to_indexed(state, attestation)
-    validate_indexed_attestation(state, indexed_attestation)
+    # Get state at the `target` to validate attestation and calculate the committees
+    indexed_attestation = convert_to_indexed(target_state, attestation)
+    validate_indexed_attestation(target_state, indexed_attestation)
 
     # Update latest targets
     for i in indexed_attestation.custody_bit_0_indices + indexed_attestation.custody_bit_1_indices:
-        if i not in store.latest_targets or target_checkpoint.epoch > store.latest_targets[i].epoch:
-            store.latest_targets[i] = target_checkpoint
+        if i not in store.latest_targets or target.epoch > store.latest_targets[i].epoch:
+            store.latest_targets[i] = target
 ```

From 751738f411842c3cf1ac7d3ac9ec828d754912b0 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 24 Jun 2019 21:01:15 -0600
Subject: [PATCH 5/9] enhance fork choice testing

---
 specs/core/0_fork-choice.md                   |  24 ++--
 .../test/fork_choice/test_on_attestation.py   | 134 ++++++++++++++++++
 .../test/fork_choice/test_on_block.py         |  95 +++++++++++++
 .../pyspec/eth2spec/test/test_fork_choice.py  |  59 --------
 4 files changed, 241 insertions(+), 71 deletions(-)
 create mode 100644 test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
 create mode 100644 test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py

diff --git a/specs/core/0_fork-choice.md b/specs/core/0_fork-choice.md
index 1818de6c4d..3ab0418374 100644
--- a/specs/core/0_fork-choice.md
+++ b/specs/core/0_fork-choice.md
@@ -58,7 +58,7 @@ The head block root associated with a `store` is defined as `get_head(store)`. A
 #### `Checkpoint`
 
 ```python
-@dataclass
+@dataclass(eq=True, frozen=True)
 class Checkpoint(object):
     epoch: Epoch
     root: Hash
@@ -69,13 +69,13 @@ class Checkpoint(object):
 ```python
 @dataclass
 class Store(object):
+    time: int
+    justified_checkpoint: Checkpoint
+    finalized_checkpoint: Checkpoint
     blocks: Dict[Hash, BeaconBlock] = field(default_factory=dict)
     block_states: Dict[Hash, BeaconState] = field(default_factory=dict)
     checkpoint_states: Dict[Checkpoint, BeaconState] = field(default_factory=dict)
-    time: int
     latest_targets: Dict[ValidatorIndex, Checkpoint] = field(default_factory=dict)
-    justified_checkpoint: Checkpoint
-    finalized_checkpoint: Checkpoint
 ```
 
 #### `get_genesis_store`
@@ -87,12 +87,12 @@ def get_genesis_store(genesis_state: BeaconState) -> Store:
     justified_checkpoint = Checkpoint(GENESIS_EPOCH, root)
     finalized_checkpoint = Checkpoint(GENESIS_EPOCH, root)
     return Store(
-        blocks={root: genesis_block},
-        block_states={root: genesis_state},
-        checkpoint_states={justified_checkpoint: genesis_state.copy()},
         time=genesis_state.genesis_time,
         justified_checkpoint=justified_checkpoint,
         finalized_checkpoint=finalized_checkpoint,
+        blocks={root: genesis_block},
+        block_states={root: genesis_state},
+        checkpoint_states={justified_checkpoint: genesis_state.copy()},
     )
 ```
 
@@ -150,13 +150,13 @@ def on_tick(store: Store, time: int) -> None:
 def on_block(store: Store, block: BeaconBlock) -> None:
     # Make a copy of the state to avoid mutability issues
     parent_block = store.blocks[block.parent_root]
-    pre_state = store.block_states[parent_block.root].copy()
+    pre_state = store.block_states[block.parent_root].copy()
     # Blocks cannot be in the future. If they are, their consideration must be delayed until the are in the past.
     assert store.time >= pre_state.genesis_time + block.slot * SECONDS_PER_SLOT
     # Add new block to the store
     store.blocks[signing_root(block)] = block
     # Check block is a descendant of the finalized block
-    assert get_ancestor(store, signing_root(block), store.blocks[get_epoch_start_slot(store.finalized_checkpoint)].slot) == store.finalized_checkpoint.root
+    assert get_ancestor(store, signing_root(block), store.blocks[store.finalized_checkpoint.root].slot) == store.finalized_checkpoint.root
     # Check that block is later than the finalized epoch slot
     assert block.slot > get_epoch_start_slot(store.finalized_checkpoint.epoch)
     # Check the block is valid and compute the post-state
@@ -167,7 +167,7 @@ def on_block(store: Store, block: BeaconBlock) -> None:
     # Update justified checkpoint
     if state.current_justified_epoch > store.justified_checkpoint.epoch:
         store.justified_checkpoint = Checkpoint(state.current_justified_epoch, state.current_justified_root)
-    elif state.previous_justified_epoch > store.justified_epoch:
+    elif state.previous_justified_epoch > store.justified_checkpoint.epoch:
         store.justified_checkpoint = Checkpoint(state.previous_justified_epoch, state.previous_justified_root)
 
     # Update finalized checkpoint
@@ -185,11 +185,11 @@ def on_attestation(store: Store, attestation: Attestation) -> None:
     assert target.root in store.blocks
 
     # Attestations cannot be from future epochs. If they are, their consideration must be delayed until the are in the past.
-    assert store.time >= pre_state.genesis_time + get_epoch_start_slot(target.epoch) * SECONDS_PER_SLOT
+    base_state = store.block_states[target.root].copy()
+    assert store.time >= base_state.genesis_time + get_epoch_start_slot(target.epoch) * SECONDS_PER_SLOT
 
     # Store target checkpoint state if not yet seen
     if target not in store.checkpoint_states:
-        base_state = store.block_states[target.root].copy()
         store.checkpoint_states[target] = process_slots(base_state, get_epoch_start_slot(target.epoch))
     target_state = store.checkpoint_states[target]
 
diff --git a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
new file mode 100644
index 0000000000..fd42a6b29b
--- /dev/null
+++ b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
@@ -0,0 +1,134 @@
+from eth2spec.utils.ssz.ssz_impl import hash_tree_root
+
+from eth2spec.test.context import with_all_phases, with_state, bls_switch
+
+from eth2spec.test.helpers.block import build_empty_block_for_next_slot
+from eth2spec.test.helpers.attestations import get_valid_attestation
+from eth2spec.test.helpers.state import next_slot
+
+
+def run_on_attestation(spec, state, store, attestation, valid=True):
+    if not valid:
+        try:
+            spec.on_attestation(store, attestation)
+        except:
+            return
+        else:
+            assert False
+
+    indexed_attestation = spec.convert_to_indexed(state, attestation)
+    spec.on_attestation(store, attestation)
+    assert (
+        store.latest_targets[indexed_attestation.custody_bit_0_indices[0]] ==
+        spec.Checkpoint(
+            epoch=attestation.data.target_epoch,
+            root=attestation.data.target_root,
+        )
+    )
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_on_attestation(spec, state):
+    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
+
+    store = spec.get_genesis_store(state)
+    time = 100
+    spec.on_tick(store, time)
+
+    block = build_empty_block_for_next_slot(spec, state, signed=True)
+
+    # store block in store
+    spec.on_block(store, block)
+
+    next_slot(spec, state)
+
+    attestation = get_valid_attestation(spec, state, slot=block.slot)
+    run_on_attestation(spec, state, store, attestation)
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_on_attestation_target_not_in_store(spec, state):
+    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
+
+    store = spec.get_genesis_store(state)
+    time = 100
+    spec.on_tick(store, time)
+
+    # move to next epoch to make block new target
+    state.slot += spec.SLOTS_PER_EPOCH
+
+    block = build_empty_block_for_next_slot(spec, state, signed=True)
+
+    # do not add block to store
+
+    next_slot(spec, state)
+    attestation = get_valid_attestation(spec, state, slot=block.slot)
+    run_on_attestation(spec, state, store, attestation, False)
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_on_attestation_future_epoch(spec, state):
+    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
+
+    store = spec.get_genesis_store(state)
+    time = 3 * spec.SECONDS_PER_SLOT
+    spec.on_tick(store, time)
+
+    block = build_empty_block_for_next_slot(spec, state, signed=True)
+
+    # store block in store
+    spec.on_block(store, block)
+    next_slot(spec, state)
+
+    # move state forward but not store
+    attestation_slot = block.slot + spec.SLOTS_PER_EPOCH
+    state.slot = attestation_slot
+
+    attestation = get_valid_attestation(spec, state, slot=state.slot)
+    run_on_attestation(spec, state, store, attestation, False)
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_on_attestation_same_slot(spec, state):
+    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
+
+    store = spec.get_genesis_store(state)
+    time = 1 * spec.SECONDS_PER_SLOT
+    spec.on_tick(store, time)
+
+    block = build_empty_block_for_next_slot(spec, state, signed=True)
+
+    spec.on_block(store, block)
+    next_slot(spec, state)
+
+    attestation = get_valid_attestation(spec, state, slot=block.slot)
+    run_on_attestation(spec, state, store, attestation, False)
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_on_attestation_invalid_attestation(spec, state):
+    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
+
+    store = spec.get_genesis_store(state)
+    time = 3 * spec.SECONDS_PER_SLOT
+    spec.on_tick(store, time)
+
+    block = build_empty_block_for_next_slot(spec, state, signed=True)
+
+    spec.on_block(store, block)
+    next_slot(spec, state)
+
+    attestation = get_valid_attestation(spec, state, slot=block.slot)
+    # make attestation invalid
+    attestation.custody_bitfield = b'\xf0' + attestation.custody_bitfield[1:]
+    run_on_attestation(spec, state, store, attestation, False)
\ No newline at end of file
diff --git a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py
new file mode 100644
index 0000000000..ef25317b69
--- /dev/null
+++ b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py
@@ -0,0 +1,95 @@
+from eth2spec.utils.ssz.ssz_impl import signing_root, hash_tree_root
+
+from eth2spec.test.context import with_all_phases, with_state, bls_switch
+
+from eth2spec.test.helpers.block import build_empty_block_for_next_slot
+
+
+def run_on_block(spec, state, store, block, valid=True):
+    if not valid:
+        try:
+            spec.on_block(store, block)
+        except:
+            return
+        else:
+            assert False
+
+    spec.on_block(store, block)
+    assert store.blocks[signing_root(block)] == block
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_basic(spec, state):
+    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
+
+    # Initialization
+    store = spec.get_genesis_store(state)
+    time = 100
+    spec.on_tick(store, time)
+    assert store.time == time
+
+    # On receiving a block of `GENESIS_SLOT + 1` slot
+    block = build_empty_block_for_next_slot(spec, state)
+    run_on_block(spec, state, store, block)
+
+    # On receiving a block of next epoch
+    store.time = time + spec.SECONDS_PER_SLOT * spec.SLOTS_PER_EPOCH
+    block = build_empty_block_for_next_slot(spec, state)
+    block.slot += spec.SLOTS_PER_EPOCH
+
+    run_on_block(spec, state, store, block)
+
+    # TODO: add tests for justified_root and finalized_root
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_on_block_future_block(spec, state):
+    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
+
+    # Initialization
+    store = spec.get_genesis_store(state)
+
+    # do not tick time
+
+    # Fail receiving block of `GENESIS_SLOT + 1` slot
+    block = build_empty_block_for_next_slot(spec, state)
+    run_on_block(spec, state, store, block, False)
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_on_block_bad_parent_root(spec, state):
+    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
+
+    # Initialization
+    store = spec.get_genesis_store(state)
+    time = 100
+    spec.on_tick(store, time)
+
+    # Fail receiving block of `GENESIS_SLOT + 1` slot
+    block = build_empty_block_for_next_slot(spec, state)
+    block.parent_root = b'\x45' * 32
+    run_on_block(spec, state, store, block, False)
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_on_block_before_finalized(spec, state):
+    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
+
+    # Initialization
+    store = spec.get_genesis_store(state)
+    time = 100
+    spec.on_tick(store, time)
+
+    store.finalized_checkpoint = spec.Checkpoint(epoch=store.finalized_checkpoint.epoch + 2, root=store.finalized_checkpoint.root)
+
+    # Fail receiving block of `GENESIS_SLOT + 1` slot
+    block = build_empty_block_for_next_slot(spec, state)
+    run_on_block(spec, state, store, block, False)
\ No newline at end of file
diff --git a/test_libs/pyspec/eth2spec/test/test_fork_choice.py b/test_libs/pyspec/eth2spec/test/test_fork_choice.py
index 4706f0eaf5..8b13789179 100644
--- a/test_libs/pyspec/eth2spec/test/test_fork_choice.py
+++ b/test_libs/pyspec/eth2spec/test/test_fork_choice.py
@@ -1,60 +1 @@
-from eth2spec.utils.ssz.ssz_impl import signing_root, hash_tree_root
 
-from eth2spec.test.context import with_all_phases, with_state, bls_switch
-
-from eth2spec.test.helpers.block import build_empty_block_for_next_slot
-from eth2spec.test.helpers.attestations import get_valid_attestation
-from eth2spec.test.helpers.state import next_slot
-
-
-@with_all_phases
-@with_state
-@bls_switch
-def test_basic(spec, state):
-    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
-
-    # Initialization
-    store = spec.get_genesis_store(state)
-    blocks = []
-    time = 100
-    spec.on_tick(store, time)
-    assert store.time == time
-
-    # On receiving a block of `GENESIS_SLOT + 1` slot
-    block = build_empty_block_for_next_slot(spec, state)
-    blocks.append(block)
-    spec.on_block(store, block)
-    assert store.blocks[signing_root(block)] == block
-
-    # On receiving a block of next epoch
-    store.time = time + spec.SECONDS_PER_SLOT * spec.SLOTS_PER_EPOCH
-    block = build_empty_block_for_next_slot(spec, state)
-    block.slot += spec.SLOTS_PER_EPOCH
-    blocks.append(block)
-
-    spec.on_block(store, block)
-    assert store.blocks[signing_root(block)] == block
-
-    # TODO: add tests for justified_root and finalized_root
-
-
-@with_all_phases
-@with_state
-@bls_switch
-def test_on_attestation(spec, state):
-    store = spec.get_genesis_store(state)
-    time = 100
-    spec.on_tick(store, time)
-
-    next_slot(spec, state)
-
-    attestation = get_valid_attestation(spec, state, slot=1)
-    indexed_attestation = spec.convert_to_indexed(state, attestation)
-    spec.on_attestation(store, attestation)
-    assert (
-        store.latest_targets[indexed_attestation.custody_bit_0_indices[0]] ==
-        spec.Target(
-            epoch=attestation.data.target_epoch,
-            root=attestation.data.target_root,
-        )
-    )

From d9b97578c0f73fb0ccd03a5727596eaec4847654 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 24 Jun 2019 21:09:57 -0600
Subject: [PATCH 6/9] lint

---
 specs/core/0_fork-choice.md                          | 12 ++++++++----
 .../eth2spec/test/fork_choice/test_on_attestation.py |  4 ++--
 .../eth2spec/test/fork_choice/test_on_block.py       |  9 ++++++---
 test_libs/pyspec/eth2spec/test/test_fork_choice.py   |  1 -
 4 files changed, 16 insertions(+), 10 deletions(-)
 delete mode 100644 test_libs/pyspec/eth2spec/test/test_fork_choice.py

diff --git a/specs/core/0_fork-choice.md b/specs/core/0_fork-choice.md
index 3ab0418374..71920d2bc8 100644
--- a/specs/core/0_fork-choice.md
+++ b/specs/core/0_fork-choice.md
@@ -149,14 +149,17 @@ def on_tick(store: Store, time: int) -> None:
 ```python
 def on_block(store: Store, block: BeaconBlock) -> None:
     # Make a copy of the state to avoid mutability issues
-    parent_block = store.blocks[block.parent_root]
+    assert block.parent_root in store.block_states
     pre_state = store.block_states[block.parent_root].copy()
     # Blocks cannot be in the future. If they are, their consideration must be delayed until the are in the past.
     assert store.time >= pre_state.genesis_time + block.slot * SECONDS_PER_SLOT
     # Add new block to the store
     store.blocks[signing_root(block)] = block
     # Check block is a descendant of the finalized block
-    assert get_ancestor(store, signing_root(block), store.blocks[store.finalized_checkpoint.root].slot) == store.finalized_checkpoint.root
+    assert (
+        get_ancestor(store, signing_root(block), store.blocks[store.finalized_checkpoint.root].slot) ==
+        store.finalized_checkpoint.root
+    )
     # Check that block is later than the finalized epoch slot
     assert block.slot > get_epoch_start_slot(store.finalized_checkpoint.epoch)
     # Check the block is valid and compute the post-state
@@ -184,13 +187,14 @@ def on_attestation(store: Store, attestation: Attestation) -> None:
     # Cannot calculate the current shuffling if have not seen the target
     assert target.root in store.blocks
 
-    # Attestations cannot be from future epochs. If they are, their consideration must be delayed until the are in the past.
+    # Attestations cannot be from future epochs. If they are, delay consideration until the epoch arrivesr
     base_state = store.block_states[target.root].copy()
     assert store.time >= base_state.genesis_time + get_epoch_start_slot(target.epoch) * SECONDS_PER_SLOT
 
     # Store target checkpoint state if not yet seen
     if target not in store.checkpoint_states:
-        store.checkpoint_states[target] = process_slots(base_state, get_epoch_start_slot(target.epoch))
+        process_slots(base_state, get_epoch_start_slot(target.epoch))
+        store.checkpoint_states[target] = base_state
     target_state = store.checkpoint_states[target]
 
     # Attestations can only affect the fork choice of subsequent slots.
diff --git a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
index fd42a6b29b..cf0e7c9cb8 100644
--- a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
+++ b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
@@ -11,7 +11,7 @@ def run_on_attestation(spec, state, store, attestation, valid=True):
     if not valid:
         try:
             spec.on_attestation(store, attestation)
-        except:
+        except AssertionError:
             return
         else:
             assert False
@@ -131,4 +131,4 @@ def test_on_attestation_invalid_attestation(spec, state):
     attestation = get_valid_attestation(spec, state, slot=block.slot)
     # make attestation invalid
     attestation.custody_bitfield = b'\xf0' + attestation.custody_bitfield[1:]
-    run_on_attestation(spec, state, store, attestation, False)
\ No newline at end of file
+    run_on_attestation(spec, state, store, attestation, False)
diff --git a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py
index ef25317b69..b18752f8c6 100644
--- a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py
+++ b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py
@@ -9,7 +9,7 @@ def run_on_block(spec, state, store, block, valid=True):
     if not valid:
         try:
             spec.on_block(store, block)
-        except:
+        except AssertionError:
             return
         else:
             assert False
@@ -88,8 +88,11 @@ def test_on_block_before_finalized(spec, state):
     time = 100
     spec.on_tick(store, time)
 
-    store.finalized_checkpoint = spec.Checkpoint(epoch=store.finalized_checkpoint.epoch + 2, root=store.finalized_checkpoint.root)
+    store.finalized_checkpoint = spec.Checkpoint(
+        epoch=store.finalized_checkpoint.epoch + 2,
+        root=store.finalized_checkpoint.root
+    )
 
     # Fail receiving block of `GENESIS_SLOT + 1` slot
     block = build_empty_block_for_next_slot(spec, state)
-    run_on_block(spec, state, store, block, False)
\ No newline at end of file
+    run_on_block(spec, state, store, block, False)
diff --git a/test_libs/pyspec/eth2spec/test/test_fork_choice.py b/test_libs/pyspec/eth2spec/test/test_fork_choice.py
deleted file mode 100644
index 8b13789179..0000000000
--- a/test_libs/pyspec/eth2spec/test/test_fork_choice.py
+++ /dev/null
@@ -1 +0,0 @@
-

From 846ca649aafece56d7aaf09bb16aa3bc5a76725b Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 25 Jun 2019 10:31:39 -0600
Subject: [PATCH 7/9] properly construct genesis latest block header in tests

---
 .../eth2spec/test/fork_choice/test_on_attestation.py | 12 ------------
 .../eth2spec/test/fork_choice/test_on_block.py       | 11 +----------
 test_libs/pyspec/eth2spec/test/helpers/genesis.py    |  4 +++-
 3 files changed, 4 insertions(+), 23 deletions(-)

diff --git a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
index cf0e7c9cb8..48f4bf46ff 100644
--- a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
+++ b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
@@ -1,5 +1,3 @@
-from eth2spec.utils.ssz.ssz_impl import hash_tree_root
-
 from eth2spec.test.context import with_all_phases, with_state, bls_switch
 
 from eth2spec.test.helpers.block import build_empty_block_for_next_slot
@@ -31,8 +29,6 @@ def run_on_attestation(spec, state, store, attestation, valid=True):
 @with_state
 @bls_switch
 def test_on_attestation(spec, state):
-    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
-
     store = spec.get_genesis_store(state)
     time = 100
     spec.on_tick(store, time)
@@ -52,8 +48,6 @@ def test_on_attestation(spec, state):
 @with_state
 @bls_switch
 def test_on_attestation_target_not_in_store(spec, state):
-    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
-
     store = spec.get_genesis_store(state)
     time = 100
     spec.on_tick(store, time)
@@ -74,8 +68,6 @@ def test_on_attestation_target_not_in_store(spec, state):
 @with_state
 @bls_switch
 def test_on_attestation_future_epoch(spec, state):
-    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
-
     store = spec.get_genesis_store(state)
     time = 3 * spec.SECONDS_PER_SLOT
     spec.on_tick(store, time)
@@ -98,8 +90,6 @@ def test_on_attestation_future_epoch(spec, state):
 @with_state
 @bls_switch
 def test_on_attestation_same_slot(spec, state):
-    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
-
     store = spec.get_genesis_store(state)
     time = 1 * spec.SECONDS_PER_SLOT
     spec.on_tick(store, time)
@@ -117,8 +107,6 @@ def test_on_attestation_same_slot(spec, state):
 @with_state
 @bls_switch
 def test_on_attestation_invalid_attestation(spec, state):
-    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
-
     store = spec.get_genesis_store(state)
     time = 3 * spec.SECONDS_PER_SLOT
     spec.on_tick(store, time)
diff --git a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py
index b18752f8c6..158ee1a58e 100644
--- a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py
+++ b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_block.py
@@ -1,7 +1,6 @@
-from eth2spec.utils.ssz.ssz_impl import signing_root, hash_tree_root
+from eth2spec.utils.ssz.ssz_impl import signing_root
 
 from eth2spec.test.context import with_all_phases, with_state, bls_switch
-
 from eth2spec.test.helpers.block import build_empty_block_for_next_slot
 
 
@@ -22,8 +21,6 @@ def run_on_block(spec, state, store, block, valid=True):
 @with_state
 @bls_switch
 def test_basic(spec, state):
-    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
-
     # Initialization
     store = spec.get_genesis_store(state)
     time = 100
@@ -48,8 +45,6 @@ def test_basic(spec, state):
 @with_state
 @bls_switch
 def test_on_block_future_block(spec, state):
-    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
-
     # Initialization
     store = spec.get_genesis_store(state)
 
@@ -64,8 +59,6 @@ def test_on_block_future_block(spec, state):
 @with_state
 @bls_switch
 def test_on_block_bad_parent_root(spec, state):
-    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
-
     # Initialization
     store = spec.get_genesis_store(state)
     time = 100
@@ -81,8 +74,6 @@ def test_on_block_bad_parent_root(spec, state):
 @with_state
 @bls_switch
 def test_on_block_before_finalized(spec, state):
-    state.latest_block_header = spec.BeaconBlockHeader(body_root=hash_tree_root(spec.BeaconBlockBody()))
-
     # Initialization
     store = spec.get_genesis_store(state)
     time = 100
diff --git a/test_libs/pyspec/eth2spec/test/helpers/genesis.py b/test_libs/pyspec/eth2spec/test/helpers/genesis.py
index d1d8189080..49e4feb7db 100644
--- a/test_libs/pyspec/eth2spec/test/helpers/genesis.py
+++ b/test_libs/pyspec/eth2spec/test/helpers/genesis.py
@@ -27,7 +27,9 @@ def create_genesis_state(spec, num_validators):
             deposit_root=deposit_root,
             deposit_count=num_validators,
             block_hash=spec.ZERO_HASH,
-        ))
+        ),
+        latest_block_header=spec.BeaconBlockHeader(body_root=spec.hash_tree_root(spec.BeaconBlockBody())),
+    )
 
     # We "hack" in the initial validators,
     #  as it is much faster than creating and processing genesis deposits for every single test case.

From 228195d89d464e5c4af7c4223808ffd33b96efda Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 25 Jun 2019 11:48:55 -0600
Subject: [PATCH 8/9] get head tests

---
 specs/core/0_fork-choice.md                   |   9 +-
 .../test/fork_choice/test_get_head.py         | 118 ++++++++++++++++++
 2 files changed, 123 insertions(+), 4 deletions(-)
 create mode 100644 test_libs/pyspec/eth2spec/test/fork_choice/test_get_head.py

diff --git a/specs/core/0_fork-choice.md b/specs/core/0_fork-choice.md
index 71920d2bc8..f74f487a1d 100644
--- a/specs/core/0_fork-choice.md
+++ b/specs/core/0_fork-choice.md
@@ -91,7 +91,7 @@ def get_genesis_store(genesis_state: BeaconState) -> Store:
         justified_checkpoint=justified_checkpoint,
         finalized_checkpoint=finalized_checkpoint,
         blocks={root: genesis_block},
-        block_states={root: genesis_state},
+        block_states={root: genesis_state.copy()},
         checkpoint_states={justified_checkpoint: genesis_state.copy()},
     )
 ```
@@ -110,10 +110,11 @@ def get_ancestor(store: Store, root: Hash, slot: Slot) -> Hash:
 ```python
 def get_latest_attesting_balance(store: Store, root: Hash) -> Gwei:
     state = store.checkpoint_states[store.justified_checkpoint]
-    active_indices = get_active_validator_indices(state.validator_registry, get_current_epoch(state))
+    active_indices = get_active_validator_indices(state, get_current_epoch(state))
     return Gwei(sum(
-        state.validator_registry[i].effective_balance for i in active_indices
-        if get_ancestor(store, store.latest_targets[i].root, store.blocks[root].slot) == root
+        state.validators[i].effective_balance for i in active_indices
+        if (i in store.latest_targets and
+            get_ancestor(store, store.latest_targets[i].root, store.blocks[root].slot) == root)
     ))
 ```
 
diff --git a/test_libs/pyspec/eth2spec/test/fork_choice/test_get_head.py b/test_libs/pyspec/eth2spec/test/fork_choice/test_get_head.py
new file mode 100644
index 0000000000..6ac46ba6c2
--- /dev/null
+++ b/test_libs/pyspec/eth2spec/test/fork_choice/test_get_head.py
@@ -0,0 +1,118 @@
+from eth2spec.test.context import with_all_phases, with_state, bls_switch
+from eth2spec.test.helpers.attestations import get_valid_attestation
+from eth2spec.test.helpers.block import build_empty_block_for_next_slot
+from eth2spec.test.helpers.state import state_transition_and_sign_block
+
+
+def add_block_to_store(spec, store, block):
+    pre_state = store.block_states[block.parent_root]
+    block_time = pre_state.genesis_time + block.slot * spec.SECONDS_PER_SLOT
+
+    if store.time < block_time:
+        spec.on_tick(store, block_time)
+
+    spec.on_block(store, block)
+
+
+def add_attestation_to_store(spec, store, attestation):
+    parent_block = store.blocks[attestation.data.beacon_block_root]
+    pre_state = store.block_states[spec.signing_root(parent_block)]
+    block_time = pre_state.genesis_time + parent_block.slot * spec.SECONDS_PER_SLOT
+    next_epoch_time = block_time + spec.SLOTS_PER_EPOCH * spec.SECONDS_PER_SLOT
+
+    if store.time < next_epoch_time:
+        spec.on_tick(store, next_epoch_time)
+
+    spec.on_attestation(store, attestation)
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_genesis(spec, state):
+    # Initialization
+    store = spec.get_genesis_store(state)
+    genesis_block = spec.BeaconBlock(state_root=state.hash_tree_root())
+    assert spec.get_head(store) == spec.signing_root(genesis_block)
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_chain_no_attestations(spec, state):
+    # Initialization
+    store = spec.get_genesis_store(state)
+    genesis_block = spec.BeaconBlock(state_root=state.hash_tree_root())
+    assert spec.get_head(store) == spec.signing_root(genesis_block)
+
+    # On receiving a block of `GENESIS_SLOT + 1` slot
+    block_1 = build_empty_block_for_next_slot(spec, state)
+    state_transition_and_sign_block(spec, state, block_1)
+    add_block_to_store(spec, store, block_1)
+
+    # On receiving a block of next epoch
+    block_2 = build_empty_block_for_next_slot(spec, state)
+    state_transition_and_sign_block(spec, state, block_2)
+    add_block_to_store(spec, store, block_2)
+
+    assert spec.get_head(store) == spec.signing_root(block_2)
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_split_tie_breaker_no_attestations(spec, state):
+    genesis_state = state.copy()
+
+    # Initialization
+    store = spec.get_genesis_store(state)
+    genesis_block = spec.BeaconBlock(state_root=state.hash_tree_root())
+    assert spec.get_head(store) == spec.signing_root(genesis_block)
+
+    # block at slot 1
+    block_1_state = genesis_state.copy()
+    block_1 = build_empty_block_for_next_slot(spec, block_1_state)
+    state_transition_and_sign_block(spec, block_1_state, block_1)
+    add_block_to_store(spec, store, block_1)
+
+    # additional block at slot 1
+    block_2_state = genesis_state.copy()
+    block_2 = build_empty_block_for_next_slot(spec, block_2_state)
+    block_2.body.graffiti = b'\x42' * 32
+    state_transition_and_sign_block(spec, block_2_state, block_2)
+    add_block_to_store(spec, store, block_2)
+
+    highest_root = max(spec.signing_root(block_1), spec.signing_root(block_2))
+
+    assert spec.get_head(store) == highest_root
+
+
+@with_all_phases
+@with_state
+@bls_switch
+def test_shorter_chain_but_heavier_weight(spec, state):
+    genesis_state = state.copy()
+
+    # Initialization
+    store = spec.get_genesis_store(state)
+    genesis_block = spec.BeaconBlock(state_root=state.hash_tree_root())
+    assert spec.get_head(store) == spec.signing_root(genesis_block)
+
+    # build longer tree
+    long_state = genesis_state.copy()
+    for i in range(3):
+        long_block = build_empty_block_for_next_slot(spec, long_state)
+        state_transition_and_sign_block(spec, long_state, long_block)
+        add_block_to_store(spec, store, long_block)
+
+    # build short tree
+    short_state = genesis_state.copy()
+    short_block = build_empty_block_for_next_slot(spec, short_state)
+    short_block.body.graffiti = b'\x42' * 32
+    state_transition_and_sign_block(spec, short_state, short_block)
+    add_block_to_store(spec, store, short_block)
+
+    short_attestation = get_valid_attestation(spec, short_state, short_block.slot, signed=True)
+    add_attestation_to_store(spec, store, short_attestation)
+
+    assert spec.get_head(store) == spec.signing_root(short_block)

From c64289677f0a5372dd1d8b6990ccc6510e0a14bc Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 25 Jun 2019 14:42:37 -0600
Subject: [PATCH 9/9] fix gethead tests

---
 specs/core/0_fork-choice.md                   | 22 ++++++++++++++-----
 .../test/fork_choice/test_on_attestation.py   |  6 ++---
 2 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/specs/core/0_fork-choice.md b/specs/core/0_fork-choice.md
index f74f487a1d..55ff91a81f 100644
--- a/specs/core/0_fork-choice.md
+++ b/specs/core/0_fork-choice.md
@@ -64,6 +64,16 @@ class Checkpoint(object):
     root: Hash
 ```
 
+#### `LatestMessage`
+
+```python
+@dataclass(eq=True, frozen=True)
+class LatestMessage(object):
+    epoch: Epoch
+    root: Hash
+```
+
+
 #### `Store`
 
 ```python
@@ -75,7 +85,7 @@ class Store(object):
     blocks: Dict[Hash, BeaconBlock] = field(default_factory=dict)
     block_states: Dict[Hash, BeaconState] = field(default_factory=dict)
     checkpoint_states: Dict[Checkpoint, BeaconState] = field(default_factory=dict)
-    latest_targets: Dict[ValidatorIndex, Checkpoint] = field(default_factory=dict)
+    latest_messages: Dict[ValidatorIndex, LatestMessage] = field(default_factory=dict)
 ```
 
 #### `get_genesis_store`
@@ -113,8 +123,8 @@ def get_latest_attesting_balance(store: Store, root: Hash) -> Gwei:
     active_indices = get_active_validator_indices(state, get_current_epoch(state))
     return Gwei(sum(
         state.validators[i].effective_balance for i in active_indices
-        if (i in store.latest_targets and
-            get_ancestor(store, store.latest_targets[i].root, store.blocks[root].slot) == root)
+        if (i in store.latest_messages and
+            get_ancestor(store, store.latest_messages[i].root, store.blocks[root].slot) == root)
     ))
 ```
 
@@ -207,8 +217,8 @@ def on_attestation(store: Store, attestation: Attestation) -> None:
     indexed_attestation = convert_to_indexed(target_state, attestation)
     validate_indexed_attestation(target_state, indexed_attestation)
 
-    # Update latest targets
+    # Update latest messages
     for i in indexed_attestation.custody_bit_0_indices + indexed_attestation.custody_bit_1_indices:
-        if i not in store.latest_targets or target.epoch > store.latest_targets[i].epoch:
-            store.latest_targets[i] = target
+        if i not in store.latest_messages or target.epoch > store.latest_messages[i].epoch:
+            store.latest_messages[i] = LatestMessage(epoch=target.epoch, root=attestation.data.beacon_block_root)
 ```
diff --git a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
index 48f4bf46ff..0e52e7fd05 100644
--- a/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
+++ b/test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py
@@ -17,10 +17,10 @@ def run_on_attestation(spec, state, store, attestation, valid=True):
     indexed_attestation = spec.convert_to_indexed(state, attestation)
     spec.on_attestation(store, attestation)
     assert (
-        store.latest_targets[indexed_attestation.custody_bit_0_indices[0]] ==
-        spec.Checkpoint(
+        store.latest_messages[indexed_attestation.custody_bit_0_indices[0]] ==
+        spec.LatestMessage(
             epoch=attestation.data.target_epoch,
-            root=attestation.data.target_root,
+            root=attestation.data.beacon_block_root,
         )
     )