*_hash -> *_root and sync block data structures

Author: hwwhww

eth/beacon/db/chain.py

@@ -58,31 +58,31 @@ def persist_block(self,
         pass
 
     @abstractmethod
-    def get_canonical_block_hash(self, slot: int) -> Hash32:
+    def get_canonical_block_root(self, slot: int) -> Hash32:
         pass
 
     @abstractmethod
     def get_canonical_block_by_slot(self, slot: int) -> BaseBeaconBlock:
         pass
 
     @abstractmethod
-    def get_canonical_block_hash_by_slot(self, slot: int) -> Hash32:
+    def get_canonical_block_root_by_slot(self, slot: int) -> Hash32:
         pass
 
     @abstractmethod
     def get_canonical_head(self) -> BaseBeaconBlock:
         pass
 
     @abstractmethod
-    def get_block_by_hash(self, block_hash: Hash32) -> BaseBeaconBlock:
+    def get_block_by_root(self, block_root: Hash32) -> BaseBeaconBlock:
         pass
 
     @abstractmethod
-    def get_score(self, block_hash: Hash32) -> int:
+    def get_score(self, block_root: Hash32) -> int:
         pass
 
     @abstractmethod
-    def block_exists(self, block_hash: Hash32) -> bool:
+    def block_exists(self, block_root: Hash32) -> bool:
         pass
 
     @abstractmethod
@@ -147,21 +147,21 @@ def _persist_block(
     #
     # Canonical Chain API
     #
-    def get_canonical_block_hash(self, slot: int) -> Hash32:
+    def get_canonical_block_root(self, slot: int) -> Hash32:
         """
-        Return the block hash for the canonical block at the given number.
+        Return the block root for the canonical block at the given number.
 
         Raise BlockNotFound if there's no block with the given number in the
         canonical chain.
         """
-        return self._get_canonical_block_hash(self.db, slot)
+        return self._get_canonical_block_root(self.db, slot)
 
     @staticmethod
-    def _get_canonical_block_hash(db: BaseDB, slot: int) -> Hash32:
+    def _get_canonical_block_root(db: BaseDB, slot: int) -> Hash32:
         validate_slot(slot)
-        slot_to_hash_key = SchemaV1.make_block_slot_to_hash_lookup_key(slot)
+        slot_to_root_key = SchemaV1.make_block_slot_to_root_lookup_key(slot)
         try:
-            encoded_key = db[slot_to_hash_key]
+            encoded_key = db[slot_to_root_key]
         except KeyError:
             raise BlockNotFound(
                 "No canonical block for block slot #{0}".format(slot)
@@ -183,25 +183,25 @@ def _get_canonical_block_by_slot(
             cls,
             db: BaseDB,
             slot: int) -> BaseBeaconBlock:
-        canonical_block_hash = cls._get_canonical_block_hash_by_slot(db, slot)
-        return cls._get_block_by_hash(db, canonical_block_hash)
+        canonical_block_root = cls._get_canonical_block_root_by_slot(db, slot)
+        return cls._get_block_by_root(db, canonical_block_root)
 
-    def get_canonical_block_hash_by_slot(self, slot: int) -> Hash32:
+    def get_canonical_block_root_by_slot(self, slot: int) -> Hash32:
         """
-        Return the block hash with the given slot in the canonical chain.
+        Return the block root with the given slot in the canonical chain.
 
         Raise BlockNotFound if there's no block with the given slot in the
         canonical chain.
         """
-        return self._get_canonical_block_hash_by_slot(self.db, slot)
+        return self._get_canonical_block_root_by_slot(self.db, slot)
 
     @classmethod
-    def _get_canonical_block_hash_by_slot(
+    def _get_canonical_block_root_by_slot(
             cls,
             db: BaseDB,
             slot: int) -> Hash32:
         validate_slot(slot)
-        return cls._get_canonical_block_hash(db, slot)
+        return cls._get_canonical_block_root(db, slot)
 
     def get_canonical_head(self) -> BaseBeaconBlock:
         """
@@ -212,48 +212,48 @@ def get_canonical_head(self) -> BaseBeaconBlock:
     @classmethod
     def _get_canonical_head(cls, db: BaseDB) -> BaseBeaconBlock:
         try:
-            canonical_head_hash = db[SchemaV1.make_canonical_head_hash_lookup_key()]
+            canonical_head_root = db[SchemaV1.make_canonical_head_root_lookup_key()]
         except KeyError:
             raise CanonicalHeadNotFound("No canonical head set for this chain")
-        return cls._get_block_by_hash(db, Hash32(canonical_head_hash))
+        return cls._get_block_by_root(db, Hash32(canonical_head_root))
 
-    def get_block_by_hash(self, block_hash: Hash32) -> BaseBeaconBlock:
-        return self._get_block_by_hash(self.db, block_hash)
+    def get_block_by_root(self, block_root: Hash32) -> BaseBeaconBlock:
+        return self._get_block_by_root(self.db, block_root)
 
     @staticmethod
-    def _get_block_by_hash(db: BaseDB, block_hash: Hash32) -> BaseBeaconBlock:
+    def _get_block_by_root(db: BaseDB, block_root: Hash32) -> BaseBeaconBlock:
         """
-        Return the requested block header as specified by block hash.
+        Return the requested block header as specified by block root.
 
         Raise BlockNotFound if it is not present in the db.
         """
-        validate_word(block_hash, title="Block Hash")
+        validate_word(block_root, title="block root")
         try:
-            block_rlp = db[block_hash]
+            block_rlp = db[block_root]
         except KeyError:
-            raise BlockNotFound("No block with hash {0} found".format(
-                encode_hex(block_hash)))
+            raise BlockNotFound("No block with root {0} found".format(
+                encode_hex(block_root)))
         return _decode_block(block_rlp)
 
-    def get_score(self, block_hash: Hash32) -> int:
-        return self._get_score(self.db, block_hash)
+    def get_score(self, block_root: Hash32) -> int:
+        return self._get_score(self.db, block_root)
 
     @staticmethod
-    def _get_score(db: BaseDB, block_hash: Hash32) -> int:
+    def _get_score(db: BaseDB, block_root: Hash32) -> int:
         try:
-            encoded_score = db[SchemaV1.make_block_hash_to_score_lookup_key(block_hash)]
+            encoded_score = db[SchemaV1.make_block_root_to_score_lookup_key(block_root)]
         except KeyError:
             raise BlockNotFound("No block with hash {0} found".format(
-                encode_hex(block_hash)))
+                encode_hex(block_root)))
         return rlp.decode(encoded_score, sedes=rlp.sedes.big_endian_int)
 
-    def block_exists(self, block_hash: Hash32) -> bool:
-        return self._block_exists(self.db, block_hash)
+    def block_exists(self, block_root: Hash32) -> bool:
+        return self._block_exists(self.db, block_root)
 
     @staticmethod
-    def _block_exists(db: BaseDB, block_hash: Hash32) -> bool:
-        validate_word(block_hash, title="Block Hash")
-        return block_hash in db
+    def _block_exists(db: BaseDB, block_root: Hash32) -> bool:
+        validate_word(block_root, title="block root")
+        return block_root in db
 
     def persist_block_chain(
         self,
@@ -308,7 +308,7 @@ def _persist_block_chain(
             score = block.slot
 
             db.set(
-                SchemaV1.make_block_hash_to_score_lookup_key(block.hash),
+                SchemaV1.make_block_root_to_score_lookup_key(block.hash),
                 rlp.encode(score, sedes=rlp.sedes.big_endian_int),
             )
 
@@ -326,38 +326,38 @@ def _persist_block_chain(
     @classmethod
     def _set_as_canonical_chain_head(
             cls, db: BaseDB,
-            block_hash: Hash32) -> Tuple[Tuple[BaseBeaconBlock, ...], Tuple[BaseBeaconBlock, ...]]:
+            block_root: Hash32) -> Tuple[Tuple[BaseBeaconBlock, ...], Tuple[BaseBeaconBlock, ...]]:
         """
         Set the canonical chain HEAD to the block as specified by the
-        given block hash.
+        given block root.
 
         :return: a tuple of the blocks that are newly in the canonical chain, and the blocks that
             are no longer in the canonical chain
         """
         try:
-            block = cls._get_block_by_hash(db, block_hash)
+            block = cls._get_block_by_root(db, block_root)
         except BlockNotFound:
             raise ValueError(
-                "Cannot use unknown block hash as canonical head: {}".format(block_hash)
+                "Cannot use unknown block root as canonical head: {}".format(block_root)
             )
 
         new_canonical_blocks = tuple(reversed(cls._find_new_ancestors(db, block)))
         old_canonical_blocks = []
 
         for block in new_canonical_blocks:
             try:
-                old_canonical_hash = cls._get_canonical_block_hash(db, block.slot)
+                old_canonical_root = cls._get_canonical_block_root(db, block.slot)
             except BlockNotFound:
                 # no old_canonical block, and no more possible
                 break
             else:
-                old_canonical_block = cls._get_block_by_hash(db, old_canonical_hash)
+                old_canonical_block = cls._get_block_by_root(db, old_canonical_root)
                 old_canonical_blocks.append(old_canonical_block)
 
         for block in new_canonical_blocks:
-            cls._add_block_slot_to_hash_lookup(db, block)
+            cls._add_block_slot_to_root_lookup(db, block)
 
-        db.set(SchemaV1.make_canonical_head_hash_lookup_key(), block.hash)
+        db.set(SchemaV1.make_canonical_head_root_lookup_key(), block.hash)
 
         return new_canonical_blocks, tuple(old_canonical_blocks)
 
@@ -392,19 +392,19 @@ def _find_new_ancestors(cls, db: BaseDB, block: BaseBeaconBlock) -> Iterable[Bas
             if block.parent_root == GENESIS_PARENT_HASH:
                 break
             else:
-                block = cls._get_block_by_hash(db, block.parent_root)
+                block = cls._get_block_by_root(db, block.parent_root)
 
     @staticmethod
-    def _add_block_slot_to_hash_lookup(db: BaseDB, block: BaseBeaconBlock) -> None:
+    def _add_block_slot_to_root_lookup(db: BaseDB, block: BaseBeaconBlock) -> None:
         """
         Set a record in the database to allow looking up this block by its
         block slot.
         """
-        block_slot_to_hash_key = SchemaV1.make_block_slot_to_hash_lookup_key(
+        block_slot_to_root_key = SchemaV1.make_block_slot_to_root_lookup_key(
             block.slot
         )
         db.set(
-            block_slot_to_hash_key,
+            block_slot_to_root_key,
             rlp.encode(block.hash, sedes=rlp.sedes.binary),
         )
 

eth/beacon/db/schema.py

@@ -11,17 +11,17 @@ class BaseSchema(ABC):
     #
     @staticmethod
     @abstractmethod
-    def make_canonical_head_hash_lookup_key() -> bytes:
+    def make_canonical_head_root_lookup_key() -> bytes:
         pass
 
     @staticmethod
     @abstractmethod
-    def make_block_slot_to_hash_lookup_key(slot: int) -> bytes:
+    def make_block_slot_to_root_lookup_key(slot: int) -> bytes:
         pass
 
     @staticmethod
     @abstractmethod
-    def make_block_hash_to_score_lookup_key(block_hash: Hash32) -> bytes:
+    def make_block_root_to_score_lookup_key(block_root: Hash32) -> bytes:
         pass
 
 
@@ -30,14 +30,14 @@ class SchemaV1(BaseSchema):
     # Block
     #
     @staticmethod
-    def make_canonical_head_hash_lookup_key() -> bytes:
-        return b'v1:beacon:canonical-head-hash'
+    def make_canonical_head_root_lookup_key() -> bytes:
+        return b'v1:beacon:canonical-head-root'
 
     @staticmethod
-    def make_block_slot_to_hash_lookup_key(slot: int) -> bytes:
-        slot_to_hash_key = b'v1:beacon:block-slot-to-hash:%d' % slot
-        return slot_to_hash_key
+    def make_block_slot_to_root_lookup_key(slot: int) -> bytes:
+        slot_to_root_key = b'v1:beacon:block-slot-to-root:%d' % slot
+        return slot_to_root_key
 
     @staticmethod
-    def make_block_hash_to_score_lookup_key(block_hash: Hash32) -> bytes:
-        return b'v1:beacon:block-hash-to-score:%s' % block_hash
+    def make_block_root_to_score_lookup_key(block_root: Hash32) -> bytes:
+        return b'v1:beacon:block-root-to-score:%s' % block_root

eth/beacon/helpers.py

@@ -76,46 +76,29 @@ def _get_element_from_recent_list(
 
 
 #
-# Get block hash(es)
+# Get block root
 #
-def get_block_hash(
-        latest_block_hashes: Sequence[Hash32],
+def get_block_root(
+        latest_block_roots: Sequence[Hash32],
         current_slot: int,
         slot: int) -> Hash32:
     """
-    Returns the block hash at a recent ``slot``.
+    Returns the block root at a recent ``slot``.
     """
-    slot_relative_position = current_slot - len(latest_block_hashes)
+    slot_relative_position = current_slot - len(latest_block_roots)
     return _get_element_from_recent_list(
-        latest_block_hashes,
+        latest_block_roots,
         slot,
         slot_relative_position,
     )
 
 
-@to_tuple
-def get_hashes_from_latest_block_hashes(
-        latest_block_hashes: Sequence[Hash32],
-        current_slot: int,
-        from_slot: int,
-        to_slot: int) -> Iterable[Hash32]:
-    """
-    Returns the block hashes between ``from_slot`` and ``to_slot``.
-    """
-    for slot in range(from_slot, to_slot + 1):
-        yield get_block_hash(
-            latest_block_hashes,
-            current_slot,
-            slot,
-        )
-
-
 #
 # Get shards_committees or indices
 #
 @to_tuple
 def _get_shard_committees_at_slot(
-        latest_state_recalculation_slot: int,
+        state_slot: int,
         shard_committees_at_slots: Sequence[Sequence[ShardCommittee]],
         slot: int,
         epoch_length: int) -> Iterable[ShardCommittee]:
@@ -127,7 +110,7 @@ def _get_shard_committees_at_slot(
             )
         )
 
-    slot_relative_position = latest_state_recalculation_slot - epoch_length
+    slot_relative_position = state_slot - epoch_length
 
     yield from _get_element_from_recent_list(
         shard_committees_at_slots,
@@ -143,7 +126,7 @@ def get_shard_committees_at_slot(state: 'BeaconState',
     Return the ``ShardCommittee`` for the ``slot``.
     """
     return _get_shard_committees_at_slot(
-        latest_state_recalculation_slot=state.latest_state_recalculation_slot,
+        state_slot=state.slot,
         shard_committees_at_slots=state.shard_committees_at_slots,
         slot=slot,
         epoch_length=epoch_length,