Merge pull request #1508 from hwwhww/rework_types

Remove outdated code and rework `eth/beacon/types` & constants

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
 
     #
@@ -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
@@ -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
+    # Beacon State API
     #
-    def get_crystallized_state_by_root(self, state_root: Hash32) -> CrystallizedState:
-        return self._get_crystallized_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_crystallized_state_by_root(db: BaseDB, state_root: Hash32) -> CrystallizedState:
+    def _get_state_by_root(db: BaseDB, state_root: Hash32) -> BeaconState:
         """
-        Return the requested crystallized state as specified by state hash.
+        Return the requested beacon state as specified by state hash.
 
         Raises StateRootNotFound if it is not present in the db.
         """
-        # TODO: validate_crystallized_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_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)
+        return _decode_state(state_rlp)
 
-    def persist_crystallized_state(self,
-                                   crystallized_state: CrystallizedState) -> None:
+    def persist_state(self,
+                      state: BeaconState) -> None:
         """
-        Persist the given CrystallizedState.
+        Persist the given BeaconState.
         """
-        return self._persist_crystallized_state(self.db, crystallized_state)
+        return self._persist_state(self.db, state)
 
     @classmethod
-    def _persist_crystallized_state(cls,
-                                    db: BaseDB,
-                                    crystallized_state: CrystallizedState) -> None:
-        cls._add_slot_to_crystallized_state_lookup(db, crystallized_state)
+    def _persist_state(cls,
+                       db: BaseDB,
+                       state: BeaconState) -> None:
         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)
-
-    @staticmethod
-    def _get_active_state_by_root(db: BaseDB, state_root: Hash32) -> ActiveState:
-        """
-        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
-        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)
-
-    def get_active_state_root_by_crystallized(self, crystallized_state_root: Hash32) -> Hash32:
-        """
-        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.
-        """
-        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),
-        )
-
-    @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,
-        )
-        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)

eth/beacon/db/schema.py

@@ -24,24 +24,6 @@ def make_block_slot_to_hash_lookup_key(slot: int) -> bytes:
     def make_block_hash_to_score_lookup_key(block_hash: Hash32) -> bytes:
         pass
 
-    #
-    # States
-    #
-    @staticmethod
-    @abstractmethod
-    def make_slot_to_crystallized_state_lookup_key(slot: int) -> bytes:
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def make_crystallized_to_active_state_root_lookup_key(state_root: Hash32) -> bytes:
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def make_deletable_state_roots_lookup_key() -> bytes:
-        pass
-
 
 class SchemaV1(BaseSchema):
     #
@@ -59,18 +41,3 @@ def make_block_slot_to_hash_lookup_key(slot: int) -> bytes:
     @staticmethod
     def make_block_hash_to_score_lookup_key(block_hash: Hash32) -> bytes:
         return b'v1:beacon:block-hash-to-score:%s' % block_hash
-
-    #
-    # States
-    #
-    @staticmethod
-    def make_slot_to_crystallized_state_lookup_key(slot: int) -> bytes:
-        return b'v1:beacon:slot-to-crystallized-state:%d' % slot
-
-    @staticmethod
-    def make_crystallized_to_active_state_root_lookup_key(state_root: Hash32) -> bytes:
-        return b'v1:beacon:crystallized-root-to-active-state-root:%s' % state_root
-
-    @staticmethod
-    def make_deletable_state_roots_lookup_key() -> bytes:
-        return b'v1:beacon:make-deletable-state-roots'

eth/beacon/enums/bls_domain.py

@@ -0,0 +1,8 @@
+from enum import IntEnum
+
+
+class BLSDomain(IntEnum):
+    DOMAIN_DEPOSIT = 0
+    DOMAIN_ATTESTATION = 1
+    DOMAIN_PROPOSAL = 2
+    DOMAIN_LOGOUT = 3

eth/beacon/enums/special_record_types.py

@@ -0,0 +1,8 @@
+from enum import IntEnum
+
+
+class SpecialRecordTypes(IntEnum):
+    LOGOUT = 0
+    CASPER_SLASHING = 1
+    PROPOSER_SLASHING = 2
+    DEPOSIT_PROOF = 3