Removed outdated code and rework eth/beacon/types

1. Update all beacon chain data structures
2. Remove `genesis_helper` and `state_machine`. Will rework them after this PR.
3. Marked or commented out some tests. Will fix it after this PR.

Author: hwwhww

eth/beacon/db/chain.py

@@ -11,9 +11,6 @@
 )
 
 import rlp
-from rlp.sedes import (
-    CountableList,
-)
 from eth_typing import (
     Hash32,
 )
@@ -36,16 +33,12 @@
     ParentNotFound,
     StateRootNotFound,
 )
-from eth.rlp.sedes import (
-    hash32,
-)
 from eth.validation import (
     validate_word,
 )
 
-from eth.beacon.types.active_states import ActiveState  # noqa: F401
+from eth.beacon.types.states import BeaconState  # noqa: F401
 from eth.beacon.types.blocks import BaseBeaconBlock  # noqa: F401
-from eth.beacon.types.crystallized_states import CrystallizedState  # noqa: F401
 from eth.beacon.validation import (
     validate_slot,
 )
@@ -100,36 +93,15 @@ def persist_block_chain(
         pass
 
     #
-    # Crystallized State
+    # Beacon State
     #
     @abstractmethod
-    def get_crystallized_state_by_root(self, state_root: Hash32) -> CrystallizedState:
+    def get_state_by_root(self, state_root: Hash32) -> BeaconState:
         pass
 
     @abstractmethod
-    def get_canonical_crystallized_state_root(self, slot: int) -> Hash32:
-        pass
-
-    @abstractmethod
-    def persist_crystallized_state(self,
-                                   crystallized_state: CrystallizedState) -> None:
-        pass
-
-    #
-    # Active State
-    #
-    @abstractmethod
-    def get_active_state_by_root(self, state_root: Hash32) -> ActiveState:
-        pass
-
-    @abstractmethod
-    def get_active_state_root_by_crystallized(self, crystallized_state_root: Hash32) -> Hash32:
-        pass
-
-    @abstractmethod
-    def persist_active_state(self,
-                             active_state: ActiveState,
-                             crystallized_state_root: Hash32) -> None:
+    def persist_state(self,
+                      state: BeaconState) -> None:
         pass
 
     #
@@ -306,25 +278,25 @@ def _persist_block_chain(
             return tuple(), tuple()
         else:
             for parent, child in sliding_window(2, blocks):
-                if parent.hash != child.parent_hash:
+                if parent.hash != child.ancestor_hashes[0]:
                     raise ValidationError(
                         "Non-contiguous chain. Expected {} to have {} as parent but was {}".format(
                             encode_hex(child.hash),
                             encode_hex(parent.hash),
-                            encode_hex(child.parent_hash),
+                            encode_hex(child.ancestor_hashes[0]),
                         )
                     )
 
-            is_genesis = first_block.parent_hash == GENESIS_PARENT_HASH
-            if not is_genesis and not cls._block_exists(db, first_block.parent_hash):
+            is_genesis = first_block.ancestor_hashes[0] == GENESIS_PARENT_HASH
+            if not is_genesis and not cls._block_exists(db, first_block.ancestor_hashes[0]):
                 raise ParentNotFound(
                     "Cannot persist block ({}) with unknown parent ({})".format(
-                        encode_hex(first_block.hash), encode_hex(first_block.parent_hash)))
+                        encode_hex(first_block.hash), encode_hex(first_block.ancestor_hashes[0])))
 
             if is_genesis:
                 score = 0
             else:
-                score = cls._get_score(db, first_block.parent_hash)
+                score = cls._get_score(db, first_block.ancestor_hashes[0])
 
         for block in blocks:
             db.set(
@@ -333,7 +305,7 @@ def _persist_block_chain(
             )
 
             # TODO: It's a stub before we implement fork choice rule
-            score += block.slot_number
+            score += block.slot
 
             db.set(
                 SchemaV1.make_block_hash_to_score_lookup_key(block.hash),
@@ -374,7 +346,7 @@ def _set_as_canonical_chain_head(
 
         for block in new_canonical_blocks:
             try:
-                old_canonical_hash = cls._get_canonical_block_hash(db, block.slot_number)
+                old_canonical_hash = cls._get_canonical_block_hash(db, block.slot)
             except BlockNotFound:
                 # no old_canonical block, and no more possible
                 break
@@ -405,7 +377,7 @@ def _find_new_ancestors(cls, db: BaseDB, block: BaseBeaconBlock) -> Iterable[Bas
         """
         while True:
             try:
-                orig = cls._get_canonical_block_by_slot(db, block.slot_number)
+                orig = cls._get_canonical_block_by_slot(db, block.slot)
             except BlockNotFound:
                 # This just means the block is not on the canonical chain.
                 pass
@@ -417,10 +389,10 @@ def _find_new_ancestors(cls, db: BaseDB, block: BaseBeaconBlock) -> Iterable[Bas
             # Found a new ancestor
             yield block
 
-            if block.parent_hash == GENESIS_PARENT_HASH:
+            if block.ancestor_hashes[0] == GENESIS_PARENT_HASH:
                 break
             else:
-                block = cls._get_block_by_hash(db, block.parent_hash)
+                block = cls._get_block_by_hash(db, block.ancestor_hashes[0])
 
     @staticmethod
     def _add_block_slot_to_hash_lookup(db: BaseDB, block: BaseBeaconBlock) -> None:
@@ -429,207 +401,48 @@ def _add_block_slot_to_hash_lookup(db: BaseDB, block: BaseBeaconBlock) -> None:
         block slot.
         """
         block_slot_to_hash_key = SchemaV1.make_block_slot_to_hash_lookup_key(
-            block.slot_number
+            block.slot
         )
         db.set(
             block_slot_to_hash_key,
             rlp.encode(block.hash, sedes=rlp.sedes.binary),
         )
 
-    #
-    # Crystallized State API
-    #
-    def get_crystallized_state_by_root(self, state_root: Hash32) -> CrystallizedState:
-        return self._get_crystallized_state_by_root(self.db, state_root)
-
-    @staticmethod
-    def _get_crystallized_state_by_root(db: BaseDB, state_root: Hash32) -> CrystallizedState:
-        """
-        Return the requested crystallized state as specified by state hash.
-
-        Raises StateRootNotFound if it is not present in the db.
-        """
-        # TODO: validate_crystallized_state_root
-        try:
-            state_rlp = db[state_root]
-        except KeyError:
-            raise StateRootNotFound("No state with root {0} found".format(
-                encode_hex(state_rlp)))
-        return _decode_crystallized_state(state_rlp)
-
-    def get_canonical_crystallized_state_root(self, slot: int) -> Hash32:
-        """
-        Return the state hash for the canonical state at the given slot.
-
-        Raises StateRootNotFound if there's no state with the given slot in the
-        canonical chain.
-        """
-        return self._get_canonical_crystallized_state_root(self.db, slot)
-
-    @staticmethod
-    def _get_canonical_crystallized_state_root(db: BaseDB, slot: int) -> Hash32:
-        validate_slot(slot)
-        slot_to_hash_key = SchemaV1.make_slot_to_crystallized_state_lookup_key(slot)
-        try:
-            encoded_key = db[slot_to_hash_key]
-        except KeyError:
-            raise StateRootNotFound(
-                "No canonical crystallized state for slot #{0}".format(slot)
-            )
-        else:
-            return rlp.decode(encoded_key, sedes=rlp.sedes.binary)
-
-    def persist_crystallized_state(self,
-                                   crystallized_state: CrystallizedState) -> None:
-        """
-        Persist the given CrystallizedState.
-        """
-        return self._persist_crystallized_state(self.db, crystallized_state)
-
-    @classmethod
-    def _persist_crystallized_state(cls,
-                                    db: BaseDB,
-                                    crystallized_state: CrystallizedState) -> None:
-        cls._add_slot_to_crystallized_state_lookup(db, crystallized_state)
-        db.set(
-            crystallized_state.hash,
-            rlp.encode(crystallized_state),
-        )
-
-    @classmethod
-    def _add_slot_to_crystallized_state_lookup(cls,
-                                               db: BaseDB,
-                                               crystallized_state: CrystallizedState) -> None:
-        """
-        Set a record in the database to allow looking up this block by its
-        last state recalculation slot.
-
-        If it's a fork, store the old state root in `deletable_state_roots`.
-        """
-        slot_to_hash_key = SchemaV1.make_slot_to_crystallized_state_lookup_key(
-            crystallized_state.last_state_recalc
-        )
-        if db.exists(slot_to_hash_key):
-            deletable_state_roots = cls._get_deletable_state_roots(db)
-            replaced_state_root = rlp.decode(db[slot_to_hash_key], sedes=rlp.sedes.binary)
-            cls._set_deletatable_state(
-                db,
-                deletable_state_roots + (replaced_state_root, ),
-            )
-        db.set(
-            slot_to_hash_key,
-            rlp.encode(crystallized_state.hash, sedes=rlp.sedes.binary),
-        )
-
-    @staticmethod
-    def _get_deletable_state_roots(db: BaseDB) -> Tuple[Hash32]:
-        """
-        Return deletable_state_roots.
-        """
-        lookup_key = SchemaV1.make_deletable_state_roots_lookup_key()
-        if not db.exists(lookup_key):
-            db.set(
-                lookup_key,
-                rlp.encode((), sedes=CountableList(hash32)),
-            )
-        deletable_state_roots = rlp.decode(db[lookup_key], sedes=CountableList(hash32))
-
-        return deletable_state_roots
-
-    @staticmethod
-    def _set_deletatable_state(db: BaseDB, deletable_state_roots: Iterable[Hash32]) -> None:
-        """
-        Set deletable_state_roots.
-        """
-        lookup_key = SchemaV1.make_deletable_state_roots_lookup_key()
-        db.set(
-            lookup_key,
-            rlp.encode(deletable_state_roots, sedes=CountableList(hash32)),
-        )
-
     #
     # Active State API
     #
-    def get_active_state_by_root(self, state_root: Hash32) -> ActiveState:
-        return self._get_active_state_by_root(self.db, state_root)
+    def get_state_by_root(self, state_root: Hash32) -> BeaconState:
+        return self._get_state_by_root(self.db, state_root)
 
     @staticmethod
-    def _get_active_state_by_root(db: BaseDB, state_root: Hash32) -> ActiveState:
+    def _get_state_by_root(db: BaseDB, state_root: Hash32) -> BeaconState:
         """
         Return the requested crystallized state as specified by state hash.
 
         Raises StateRootNotFound if it is not present in the db.
         """
-        # TODO: validate_active_state_root
+        # TODO: validate_state_root
         try:
             state_rlp = db[state_root]
         except KeyError:
             raise StateRootNotFound("No state with root {0} found".format(
                 encode_hex(state_rlp)))
-        return _decode_active_state(state_rlp)
+        return _decode_state(state_rlp)
 
-    def get_active_state_root_by_crystallized(self, crystallized_state_root: Hash32) -> Hash32:
+    def persist_state(self,
+                      state: BeaconState) -> None:
         """
-        Return the state hash for the canonical state at the given crystallized_state_root.
-
-        Raises StateRootNotFound if there's no state with the given slot in the
-        canonical chain.
+        Persist the given BeaconState.
         """
-        return self._get_active_state_root_by_crystallized(self.db, crystallized_state_root)
-
-    @staticmethod
-    def _get_active_state_root_by_crystallized(db: BaseDB,
-                                               crystallized_state_root: Hash32) -> Hash32:
-        state_root_to_hash_key = SchemaV1.make_crystallized_to_active_state_root_lookup_key(
-            crystallized_state_root
-        )
-        try:
-            encoded_key = db[state_root_to_hash_key]
-        except KeyError:
-            raise StateRootNotFound(
-                "No canonical active state for crystallized_state_root #{0}".format(
-                    state_root_to_hash_key
-                )
-            )
-        else:
-            return rlp.decode(encoded_key, sedes=rlp.sedes.binary)
-
-    def persist_active_state(self,
-                             active_state: ActiveState,
-                             crystallized_state_root: Hash32) -> None:
-        """
-        Persist the given ActiveState.
-
-        NOTE: only persist active state when recalcuate crystallized state.
-        """
-        return self._persist_active_state(self.db, active_state, crystallized_state_root)
-
-    @classmethod
-    def _persist_active_state(cls,
-                              db: BaseDB,
-                              active_state: ActiveState,
-                              crystallized_state_root: Hash32) -> None:
-        cls._add_crystallized_to_active_state_lookup(db, active_state, crystallized_state_root)
-        db.set(
-            active_state.hash,
-            rlp.encode(active_state),
-        )
+        return self._persist_state(self.db, state)
 
     @classmethod
-    def _add_crystallized_to_active_state_lookup(cls,
-                                                 db: BaseDB,
-                                                 active_state: ActiveState,
-                                                 crystallized_state_root: Hash32) -> None:
-        """
-        Set a record in the database to allow looking up this block by its
-        last state recalculation slot.
-        """
-        slot_to_hash_key = SchemaV1.make_crystallized_to_active_state_root_lookup_key(
-            crystallized_state_root,
-        )
+    def _persist_state(cls,
+                       db: BaseDB,
+                       state: BeaconState) -> None:
         db.set(
-            slot_to_hash_key,
-            rlp.encode(active_state.hash, sedes=rlp.sedes.binary),
+            state.hash,
+            rlp.encode(state),
         )
 
     #
@@ -659,12 +472,6 @@ def _decode_block(block_rlp: bytes) -> BaseBeaconBlock:
 
 
 @functools.lru_cache(128)
-def _decode_crystallized_state(crystallized_state_rlp: bytes) -> CrystallizedState:
-    # TODO: forkable CrystallizedState fields?
-    return rlp.decode(crystallized_state_rlp, sedes=CrystallizedState)
-
-
-@functools.lru_cache(128)
-def _decode_active_state(active_state_rlp: bytes) -> ActiveState:
-    # TODO: forkable CrystallizedState fields?
-    return rlp.decode(active_state_rlp, sedes=ActiveState)
+def _decode_state(state_rlp: bytes) -> BeaconState:
+    # TODO: forkable BeaconState fields?
+    return rlp.decode(state_rlp, sedes=BeaconState)