Add basic test case

sync/optimistic.md

@@ -88,8 +88,8 @@ Let `current_slot: Slot` be `(time - genesis_time) // SECONDS_PER_SLOT` where
 class OptimisticStore(object):
     optimistic_roots: Set[Root]
     head_block_root: Root
-    blocks: Dict[Root, BeaconBlock]
-    block_states: Dict[Root, BeaconState]
+    blocks: Dict[Root, BeaconBlock] = field(default_factory=dict)
+    block_states: Dict[Root, BeaconState] = field(default_factory=dict)
 ```
 
 ```python

tests/core/pyspec/eth2spec/test/bellatrix/sync/test_optimistic.py

@@ -0,0 +1,98 @@
+from eth2spec.test.context import (
+    spec_state_test,
+    with_bellatrix_and_later,
+)
+from eth2spec.test.helpers.attestations import (
+    state_transition_with_full_block,
+)
+from eth2spec.test.helpers.block import (
+    build_empty_block_for_next_slot,
+)
+from eth2spec.test.helpers.fork_choice import (
+    get_genesis_forkchoice_store_and_block,
+    on_tick_and_append_step,
+)
+from eth2spec.test.helpers.optimistic_sync import (
+    PayloadStatusV1,
+    PayloadStatusV1Status,
+    MegaStore,
+    add_optimistic_block,
+    get_optimistic_store,
+)
+from eth2spec.test.helpers.state import (
+    next_epoch,
+    state_transition_and_sign_block,
+)
+
+
+@with_bellatrix_and_later
+@spec_state_test
+def test_from_syncing_to_invalid(spec, state):
+    test_steps = []
+    # Initialization
+    fc_store, anchor_block = get_genesis_forkchoice_store_and_block(spec, state)
+    op_store = get_optimistic_store(spec, state, anchor_block)
+    mega_store = MegaStore(spec, fc_store, op_store)
+    yield 'anchor_state', state
+    yield 'anchor_block', anchor_block
+
+    next_epoch(spec, state)
+
+    current_time = (
+        (spec.SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY * 10 + state.slot) * spec.config.SECONDS_PER_SLOT
+        + fc_store.genesis_time
+    )
+    on_tick_and_append_step(spec, fc_store, current_time, test_steps)
+
+    # Block 0
+    block_0 = build_empty_block_for_next_slot(spec, state)
+    block_0.body.execution_payload.block_hash = spec.hash(bytes(f'block_0', 'UTF-8'))
+    signed_block = state_transition_and_sign_block(spec, state, block_0)
+    yield from add_optimistic_block(spec, mega_store, signed_block, test_steps, status=PayloadStatusV1Status.VALID)
+    assert spec.get_head(mega_store.fc_store) == mega_store.opt_store.head_block_root
+
+    state_0 = state.copy()
+
+    # Create VALID chain `a`
+    signed_blocks_a = []
+    for i in range(3):
+        block = build_empty_block_for_next_slot(spec, state)
+        block.body.execution_payload.block_hash = spec.hash(bytes(f'chain_a_{i}', 'UTF-8'))
+        block.body.execution_payload.parent_hash = (
+            spec.hash(bytes(f'chain_a_{i - 1}', 'UTF-8')) if i != 0 else block_0.body.execution_payload.block_hash
+        )
+
+        signed_block = state_transition_and_sign_block(spec, state, block)
+        yield from add_optimistic_block(spec, mega_store, signed_block, test_steps, status=PayloadStatusV1Status.VALID)
+        assert spec.get_head(mega_store.fc_store) == mega_store.opt_store.head_block_root
+        signed_blocks_a.append(signed_block.copy())
+
+    # Create SYNCING chain `b`
+    signed_blocks_b = []
+    state = state_0.copy()
+    for i in range(3):
+        block = build_empty_block_for_next_slot(spec, state)
+        block.body.execution_payload.block_hash = spec.hash(bytes(f'chain_b_{i}', 'UTF-8'))
+        block.body.execution_payload.parent_hash = (
+            spec.hash(bytes(f'chain_b_{i - 1}', 'UTF-8')) if i != 0 else block_0.body.execution_payload.block_hash
+        )
+        signed_block = state_transition_with_full_block(spec, state, True, True, block=block)
+        signed_blocks_b.append(signed_block.copy())
+        yield from add_optimistic_block(spec, mega_store, signed_block, test_steps,
+                                        status=PayloadStatusV1Status.SYNCING)
+        assert spec.get_head(mega_store.fc_store) == mega_store.opt_store.head_block_root
+
+    # Now add block 4 to chain `b` with INVALID
+    block = build_empty_block_for_next_slot(spec, state)
+    block.body.execution_payload.block_hash = spec.hash(bytes(f'chain_b_3', 'UTF-8'))
+    block.body.execution_payload.parent_hash = signed_blocks_b[-1].message.body.execution_payload.block_hash
+    signed_block = state_transition_and_sign_block(spec, state, block)
+    payload_status = PayloadStatusV1(
+        status=PayloadStatusV1Status.INVALID,
+        latest_valid_hash=block_0.body.execution_payload.block_hash,
+        validation_error="invalid",
+    )
+    yield from add_optimistic_block(spec, mega_store, signed_block, test_steps, payload_status=payload_status)
+    assert mega_store.opt_store.head_block_root == signed_blocks_a[-1].message.hash_tree_root()
+
+    yield 'steps', test_steps

tests/core/pyspec/eth2spec/test/helpers/attestations.py

@@ -251,10 +251,12 @@ def state_transition_with_full_block(spec,
                                      fill_cur_epoch,
                                      fill_prev_epoch,
                                      participation_fn=None,
-                                     sync_aggregate=None):
+                                     sync_aggregate=None,
+                                     block=None):
     """
     Build and apply a block with attestions at the calculated `slot_to_attest` of current epoch and/or previous epoch.
     """
+    if block is None:
         block = build_empty_block_for_next_slot(spec, state)
     if fill_cur_epoch and state.slot >= spec.MIN_ATTESTATION_INCLUSION_DELAY:
         slot_to_attest = state.slot - spec.MIN_ATTESTATION_INCLUSION_DELAY + 1

tests/core/pyspec/eth2spec/test/helpers/fork_choice.py

@@ -13,18 +13,8 @@ def get_anchor_root(spec, state):
     return spec.hash_tree_root(anchor_block_header)
 
 
-def add_block_to_store(spec, store, signed_block):
-    pre_state = store.block_states[signed_block.message.parent_root]
-    block_time = pre_state.genesis_time + signed_block.message.slot * spec.config.SECONDS_PER_SLOT
-
-    if store.time < block_time:
-        spec.on_tick(store, block_time)
-
-    spec.on_block(store, signed_block)
-
-
 def tick_and_add_block(spec, store, signed_block, test_steps, valid=True,
-                       merge_block=False, block_not_found=False):
+                       merge_block=False, block_not_found=False, is_optimistic=False):
     pre_state = store.block_states[signed_block.message.parent_root]
     block_time = pre_state.genesis_time + signed_block.message.slot * spec.config.SECONDS_PER_SLOT
     if merge_block:
@@ -37,6 +27,7 @@ def tick_and_add_block(spec, store, signed_block, test_steps, valid=True,
         spec, store, signed_block, test_steps,
         valid=valid,
         block_not_found=block_not_found,
+        is_optimistic=is_optimistic,
     )
 
     return post_state
@@ -119,13 +110,21 @@ def add_block(spec,
               signed_block,
               test_steps,
               valid=True,
-              block_not_found=False):
+              block_not_found=False,
+              is_optimistic=False):
     """
     Run on_block and on_attestation
     """
     yield get_block_file_name(signed_block), signed_block
 
     if not valid:
+        if is_optimistic:
+            run_on_block(spec, store, signed_block, valid=True)
+            test_steps.append({
+                'block': get_block_file_name(signed_block),
+                'valid': False,
+            })
+        else:
             try:
                 run_on_block(spec, store, signed_block, valid=True)
             except (AssertionError, BlockNotFoundException) as e:
@@ -153,6 +152,7 @@ def add_block(spec,
     block_root = signed_block.message.hash_tree_root()
     assert store.blocks[block_root] == signed_block.message
     assert store.block_states[block_root].hash_tree_root() == signed_block.message.state_root
+    if not is_optimistic:
         test_steps.append({
             'checks': {
                 'time': int(store.time),

tests/core/pyspec/eth2spec/test/helpers/optimistic_sync.py

@@ -0,0 +1,189 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import (
+    Dict,
+    Optional,
+)
+
+from eth_utils import encode_hex
+
+from eth2spec.utils.ssz.ssz_typing import Bytes32
+from eth2spec.test.helpers.fork_choice import (
+    add_block,
+)
+
+
+class PayloadStatusV1StatusAlias(Enum):
+    NOT_VALIDATED = "NOT_VALIDATED"
+    INVALIDATED = "INVALIDATED"
+
+
+class PayloadStatusV1Status(Enum):
+    VALID = "VALID"
+    INVALID = "INVALID"
+    SYNCING = "SYNCING"
+    ACCEPTED = "ACCEPTED"
+    INVALID_BLOCK_HASH = "INVALID_BLOCK_HASH"
+
+    @property
+    def alias(self) -> PayloadStatusV1StatusAlias:
+        if self.value in (self.SYNCING.value, self.ACCEPTED.value):
+            return PayloadStatusV1StatusAlias.NOT_VALIDATED
+        elif self.value in (self.INVALID.value, self.INVALID_BLOCK_HASH.value):
+            return PayloadStatusV1StatusAlias.INVALIDATED
+
+
+@dataclass
+class PayloadStatusV1:
+    status: PayloadStatusV1Status = PayloadStatusV1Status.VALID
+    latest_valid_hash: Optional[Bytes32] = None
+    validation_error: Optional[str] = None
+
+    @property
+    def formatted_output(self):
+        return {
+            'status': str(self.status),
+            'latest_valid_hash': encode_hex(self.latest_valid_hash) if self.latest_valid_hash is not None else 'null',
+            'validation_error': str(self.validation_error) if self.validation_error is not None else 'null'
+        }
+
+
+class MegaStore(object):
+    spec = None
+    fc_store = None
+    opt_store = None
+    block_payload_statuses: Dict[Bytes32, PayloadStatusV1] = dict()
+
+    def __init__(self, spec, fc_store, opt_store):
+        self.spec = spec
+        self.fc_store = fc_store
+        self.opt_store = opt_store
+
+
+def get_optimistic_store(spec, anchor_state, anchor_block):
+    assert anchor_block.state_root == anchor_state.hash_tree_root()
+
+    opt_store = spec.OptimisticStore(
+        optimistic_roots=set(),
+        head_block_root=anchor_block.hash_tree_root(),
+
+    )
+    anchor_block_root = anchor_block.hash_tree_root()
+    opt_store.blocks[anchor_block_root] = anchor_block.copy()
+    opt_store.block_states[anchor_block_root] = anchor_state.copy()
+
+    return opt_store
+
+
+def add_optimistic_block(spec, mega_store, signed_block, test_steps,
+                         payload_status=None, status=PayloadStatusV1Status.SYNCING):
+    block = signed_block.message
+    block_root = block.hash_tree_root()
+    el_block_hash = block.body.execution_payload.block_hash
+
+    if payload_status is None:
+        payload_status = PayloadStatusV1(status=status)
+        if payload_status.status == PayloadStatusV1Status.VALID:
+            payload_status.latest_valid_hash = el_block_hash
+
+    mega_store.block_payload_statuses[block_root] = payload_status
+    test_steps.append({
+        'payload_status': payload_status.formatted_output,
+    })
+
+    # Optimistic sync
+
+    valid = True
+
+    # Case: INVALID
+    if payload_status.status == PayloadStatusV1Status.INVALID:
+        # Update parent status to INVALID
+        assert payload_status.latest_valid_hash is not None
+        current_block = block
+        while el_block_hash != payload_status.latest_valid_hash and el_block_hash != spec.Bytes32():
+            current_block_root = current_block.hash_tree_root()
+            assert current_block_root in mega_store.block_payload_statuses
+            mega_store.block_payload_statuses[current_block_root].status = PayloadStatusV1Status.INVALID
+            # Get parent
+            current_block = mega_store.fc_store.blocks[current_block.parent_root]
+            el_block_hash = current_block.body.execution_payload.block_hash
+
+    if payload_status.status != PayloadStatusV1Status.VALID:
+        valid = False
+
+    yield from add_block(spec, mega_store.fc_store, signed_block,
+                         valid=valid,
+                         test_steps=test_steps,
+                         is_optimistic=True)
+
+    # Update stores
+    is_optimistic_candidate = spec.is_optimistic_candidate_block(
+        mega_store.opt_store,
+        current_slot=spec.get_current_slot(mega_store.fc_store),
+        block=signed_block.message,
+    )
+    if is_optimistic_candidate:
+        mega_store.opt_store.optimistic_roots.add(block_root)
+        mega_store.opt_store.blocks[block_root] = signed_block.message.copy()
+        if not is_invalidated(mega_store, block_root):
+            mega_store.opt_store.block_states[block_root] = mega_store.fc_store.block_states[block_root].copy()
+
+    # Clean up the invalidated blocks
+    clean_up_store(mega_store)
+
+    # Update head
+    mega_store.opt_store.head_block_root = get_opt_head_block_root(spec, mega_store)
+    test_steps.append({
+        'checks': {
+            'head': get_formatted_optimistic_head_output(mega_store),
+        }
+    })
+
+
+def get_opt_head_block_root(spec, mega_store):
+    """
+    Copied and modified from fork-choice spec `get_head` function.
+    """
+    store = mega_store.fc_store
+
+    # Get filtered block tree that only includes viable branches
+    blocks = spec.get_filtered_block_tree(store)
+    # Execute the LMD-GHOST fork choice
+    head = store.justified_checkpoint.root
+    while True:
+        children = [
+            root for root in blocks.keys()
+            if (
+                blocks[root].parent_root == head
+                and not is_invalidated(mega_store, root)  # For optimistic sync
+            )
+        ]
+        if len(children) == 0:
+            return head
+        # Sort by latest attesting balance with ties broken lexicographically
+        # Ties broken by favoring block with lexicographically higher root
+        head = max(children, key=lambda root: (spec.get_latest_attesting_balance(store, root), root))
+
+
+def is_invalidated(mega_store, block_root):
+    if block_root in mega_store.block_payload_statuses:
+        return mega_store.block_payload_statuses[block_root].status.alias == PayloadStatusV1StatusAlias.INVALIDATED
+    else:
+        return False
+
+
+def get_formatted_optimistic_head_output(mega_store):
+    head = mega_store.opt_store.head_block_root
+    slot = mega_store.fc_store.blocks[head].slot
+    return {
+        'slot': int(slot),
+        'root': encode_hex(head),
+    }
+
+
+def clean_up_store(mega_store):
+    """
+    Remove invalidated blocks
+    """
+    # TODO
+    ...

tests/generators/sync/main.py

@@ -0,0 +1,14 @@
+from eth2spec.gen_helpers.gen_from_tests.gen import run_state_test_generators
+from eth2spec.test.helpers.constants import BELLATRIX
+
+
+if __name__ == "__main__":
+    bellatrix_mods = {key: 'eth2spec.test.bellatrix.sync.test_' + key for key in [
+        'optimistic',
+    ]}
+
+    all_mods = {
+        BELLATRIX: bellatrix_mods,
+    }
+
+    run_state_test_generators(runner_name="sync", all_mods=all_mods)

tests/generators/sync/requirements.txt

@@ -0,0 +1,2 @@
+pytest>=4.4
+../../../[generator]