Replace other .hash to .root

Author: hwwhww

eth/beacon/db/chain.py

@@ -278,11 +278,11 @@ def _persist_block_chain(
             return tuple(), tuple()
         else:
             for parent, child in sliding_window(2, blocks):
-                if parent.hash != child.parent_root:
+                if parent.root != child.parent_root:
                     raise ValidationError(
                         "Non-contiguous chain. Expected {} to have {} as parent but was {}".format(
-                            encode_hex(child.hash),
-                            encode_hex(parent.hash),
+                            encode_hex(child.root),
+                            encode_hex(parent.root),
                             encode_hex(child.parent_root),
                         )
                     )
@@ -291,7 +291,7 @@ def _persist_block_chain(
             if not is_genesis and not cls._block_exists(db, first_block.parent_root):
                 raise ParentNotFound(
                     "Cannot persist block ({}) with unknown parent ({})".format(
-                        encode_hex(first_block.hash), encode_hex(first_block.parent_root)))
+                        encode_hex(first_block.root), encode_hex(first_block.parent_root)))
 
             if is_genesis:
                 score = 0
@@ -300,26 +300,26 @@ def _persist_block_chain(
 
         for block in blocks:
             db.set(
-                block.hash,
+                block.root,
                 rlp.encode(block),
             )
 
             # TODO: It's a stub before we implement fork choice rule
             score = block.slot
 
             db.set(
-                SchemaV1.make_block_root_to_score_lookup_key(block.hash),
+                SchemaV1.make_block_root_to_score_lookup_key(block.root),
                 rlp.encode(score, sedes=rlp.sedes.big_endian_int),
             )
 
         try:
-            previous_canonical_head = cls._get_canonical_head(db).hash
+            previous_canonical_head = cls._get_canonical_head(db).root
             head_score = cls._get_score(db, previous_canonical_head)
         except CanonicalHeadNotFound:
-            return cls._set_as_canonical_chain_head(db, block.hash)
+            return cls._set_as_canonical_chain_head(db, block.root)
 
         if score > head_score:
-            return cls._set_as_canonical_chain_head(db, block.hash)
+            return cls._set_as_canonical_chain_head(db, block.root)
         else:
             return tuple(), tuple()
 
@@ -357,7 +357,7 @@ def _set_as_canonical_chain_head(
         for block in new_canonical_blocks:
             cls._add_block_slot_to_root_lookup(db, block)
 
-        db.set(SchemaV1.make_canonical_head_root_lookup_key(), block.hash)
+        db.set(SchemaV1.make_canonical_head_root_lookup_key(), block.root)
 
         return new_canonical_blocks, tuple(old_canonical_blocks)
 
@@ -382,7 +382,7 @@ def _find_new_ancestors(cls, db: BaseDB, block: BaseBeaconBlock) -> Iterable[Bas
                 # This just means the block is not on the canonical chain.
                 pass
             else:
-                if orig.hash == block.hash:
+                if orig.root == block.root:
                     # Found the common ancestor, stop.
                     break
 
@@ -405,7 +405,7 @@ def _add_block_slot_to_root_lookup(db: BaseDB, block: BaseBeaconBlock) -> None:
         )
         db.set(
             block_slot_to_root_key,
-            rlp.encode(block.hash, sedes=rlp.sedes.binary),
+            rlp.encode(block.root, sedes=rlp.sedes.binary),
         )
 
     #
@@ -441,7 +441,7 @@ def _persist_state(cls,
                        db: BaseDB,
                        state: BeaconState) -> None:
         db.set(
-            state.hash,
+            state.root,
             rlp.encode(state),
         )
 

eth/beacon/types/blocks.py

@@ -91,7 +91,7 @@ def __init__(self,
     def __repr__(self) -> str:
         return '<Block #{0} {1}>'.format(
             self.slot,
-            encode_hex(self.hash)[2:10],
+            encode_hex(self.root)[2:10],
         )
 
     _hash = None
@@ -104,7 +104,8 @@ def hash(self) -> Hash32:
 
     @property
     def root(self) -> Hash32:
-        # Alias
+        # Alias of `hash`.
+        # Using flat hash, might change to SSZ tree hash.
         return self.hash
 
     @property

eth/beacon/types/states.py

@@ -88,67 +88,52 @@ def __init__(
             justification_bitfield: int,
             finalized_slot: int,
             processed_pow_receipt_root: Hash32,
-            validator_registry: Sequence[ValidatorRecord]=None,
-            shard_committees_at_slots: Sequence[Sequence[ShardCommittee]]=None,
-            persistent_committees: Sequence[Sequence[int]]=None,
-            persistent_committee_reassignments: Sequence[ShardReassignmentRecord]=None,
-            latest_crosslinks: Sequence[CrosslinkRecord]=None,
-            latest_block_roots: Sequence[Hash32]=None,
-            latest_penalized_exit_balances: Sequence[int]=None,
-            batched_block_roots: Sequence[Hash32]=None,
-            latest_attestations: Sequence[PendingAttestationRecord]=None,
-            candidate_pow_receipt_roots: Sequence[CandidatePoWReceiptRootRecord]=None
+            validator_registry: Sequence[ValidatorRecord]=(),
+            shard_committees_at_slots: Sequence[Sequence[ShardCommittee]]=(),
+            persistent_committees: Sequence[Sequence[int]]=(),
+            persistent_committee_reassignments: Sequence[ShardReassignmentRecord]=(),
+            latest_crosslinks: Sequence[CrosslinkRecord]=(),
+            latest_block_roots: Sequence[Hash32]=(),
+            latest_penalized_exit_balances: Sequence[int]=(),
+            batched_block_roots: Sequence[Hash32]=(),
+            latest_attestations: Sequence[PendingAttestationRecord]=(),
+            candidate_pow_receipt_roots: Sequence[CandidatePoWReceiptRootRecord]=()
     ) -> None:
-        if validator_registry is None:
-            validator_registry = ()
-        if shard_committees_at_slots is None:
-            shard_committees_at_slots = ()
-        if persistent_committees is None:
-            persistent_committees = ()
-        if persistent_committee_reassignments is None:
-            persistent_committee_reassignments = ()
-        if latest_crosslinks is None:
-            latest_crosslinks = ()
-        if latest_block_roots is None:
-            latest_block_roots = ()
-        if latest_penalized_exit_balances is None:
-            latest_penalized_exit_balances = ()
-        if batched_block_roots is None:
-            batched_block_roots = ()
-        if latest_attestations is None:
-            latest_attestations = ()
-        if candidate_pow_receipt_roots is None:
-            candidate_pow_receipt_roots = ()
-
         super().__init__(
+            # Misc
             slot=slot,
             genesis_time=genesis_time,
             fork_data=fork_data,
+            # Validator registry
             validator_registry=validator_registry,
             validator_registry_latest_change_slot=validator_registry_latest_change_slot,
             validator_registry_exit_count=validator_registry_exit_count,
             validator_registry_delta_chain_tip=validator_registry_delta_chain_tip,
+            # Randomness and committees
             randao_mix=randao_mix,
             next_seed=next_seed,
             shard_committees_at_slots=shard_committees_at_slots,
             persistent_committees=persistent_committees,
             persistent_committee_reassignments=persistent_committee_reassignments,
+            # Finality
             previous_justified_slot=previous_justified_slot,
             justified_slot=justified_slot,
             justification_bitfield=justification_bitfield,
             finalized_slot=finalized_slot,
+            # Recent state
             latest_crosslinks=latest_crosslinks,
             latest_block_roots=latest_block_roots,
             latest_penalized_exit_balances=latest_penalized_exit_balances,
             latest_attestations=latest_attestations,
             batched_block_roots=batched_block_roots,
+            # PoW receipt root
             processed_pow_receipt_root=processed_pow_receipt_root,
             candidate_pow_receipt_roots=candidate_pow_receipt_roots,
         )
 
     def __repr__(self) -> str:
         return 'BeaconState #{0}>'.format(
-            encode_hex(self.hash)[2:10],
+            encode_hex(self.root)[2:10],
         )
 
     _hash = None
@@ -161,7 +146,8 @@ def hash(self) -> Hash32:
 
     @property
     def root(self) -> Hash32:
-        # Alias
+        # Alias of `hash`.
+        # Using flat hash, might change to SSZ tree hash.
         return self.hash
 
     @property

tests/beacon/db/test_chaindb.py

@@ -56,13 +56,13 @@ def test_chaindb_add_block_number_to_root_lookup(chaindb, block):
 
 def test_chaindb_persist_block_and_slot_to_root(chaindb, block):
     with pytest.raises(BlockNotFound):
-        chaindb.get_block_by_root(block.hash)
-    slot_to_root_key = SchemaV1.make_block_root_to_score_lookup_key(block.hash)
+        chaindb.get_block_by_root(block.root)
+    slot_to_root_key = SchemaV1.make_block_root_to_score_lookup_key(block.root)
     assert not chaindb.exists(slot_to_root_key)
 
     chaindb.persist_block(block)
 
-    assert chaindb.get_block_by_root(block.hash) == block
+    assert chaindb.get_block_by_root(block.root) == block
     assert chaindb.exists(slot_to_root_key)
 
 
@@ -74,7 +74,7 @@ def test_chaindb_persist_block_and_unknown_parent(chaindb, block, seed):
 
 
 def test_chaindb_persist_block_and_block_to_root(chaindb, block):
-    block_to_root_key = SchemaV1.make_block_root_to_score_lookup_key(block.hash)
+    block_to_root_key = SchemaV1.make_block_root_to_score_lookup_key(block.root)
     assert not chaindb.exists(block_to_root_key)
     chaindb.persist_block(block)
     assert chaindb.exists(block_to_root_key)
@@ -87,37 +87,37 @@ def test_chaindb_get_score(chaindb, sample_beacon_block_params):
     )
     chaindb.persist_block(genesis)
 
-    genesis_score_key = SchemaV1.make_block_root_to_score_lookup_key(genesis.hash)
+    genesis_score_key = SchemaV1.make_block_root_to_score_lookup_key(genesis.root)
     genesis_score = rlp.decode(chaindb.db.get(genesis_score_key), sedes=rlp.sedes.big_endian_int)
     assert genesis_score == 0
-    assert chaindb.get_score(genesis.hash) == 0
+    assert chaindb.get_score(genesis.root) == 0
 
     block1 = BaseBeaconBlock(**sample_beacon_block_params).copy(
-        parent_root=genesis.hash,
+        parent_root=genesis.root,
         slot=1,
     )
     chaindb.persist_block(block1)
 
-    block1_score_key = SchemaV1.make_block_root_to_score_lookup_key(block1.hash)
+    block1_score_key = SchemaV1.make_block_root_to_score_lookup_key(block1.root)
     block1_score = rlp.decode(chaindb.db.get(block1_score_key), sedes=rlp.sedes.big_endian_int)
     assert block1_score == 1
-    assert chaindb.get_score(block1.hash) == 1
+    assert chaindb.get_score(block1.root) == 1
 
 
 def test_chaindb_get_block_by_root(chaindb, block):
     chaindb.persist_block(block)
-    result_block = chaindb.get_block_by_root(block.hash)
+    result_block = chaindb.get_block_by_root(block.root)
     validate_rlp_equal(result_block, block)
 
 
 def test_chaindb_get_canonical_block_root(chaindb, block):
     chaindb.persist_block(block)
     block_root = chaindb.get_canonical_block_root(block.slot)
-    assert block_root == block.hash
+    assert block_root == block.root
 
 
 def test_chaindb_state(chaindb, state):
     chaindb.persist_state(state)
 
-    result_state = chaindb.get_state_by_root(state.hash)
-    assert result_state.hash == state.hash
+    result_state = chaindb.get_state_by_root(state.root)
+    assert result_state.root == state.root

tests/beacon/helpers.py

@@ -31,6 +31,6 @@ def get_pseudo_chain(length, genesis_block):
     for slot in range(1, length * 3):
         block = genesis_block.copy(
             slot=slot,
-            parent_root=block.hash
+            parent_root=block.root
         )
         yield block

tests/beacon/test_helpers.py

@@ -74,7 +74,7 @@ def generate_mock_latest_block_roots(
         b'\x00' * 32
         for i
         in range(epoch_length * 2 - current_block_number)
-    ] + [block.hash for block in blocks[:current_block_number]]
+    ] + [block.root for block in blocks[:current_block_number]]
     return blocks, latest_block_roots
 
 
@@ -144,7 +144,7 @@ def test_get_block_root(
             current_block_number,
             target_slot,
         )
-        assert block_root == blocks[target_slot].hash
+        assert block_root == blocks[target_slot].root
     else:
         with pytest.raises(ValueError):
             get_block_root(

tests/beacon/types/test_states.py

@@ -98,4 +98,4 @@ def test_num_crosslink_records(expected,
 
 def test_hash(sample_beacon_state_params):
     state = BeaconState(**sample_beacon_state_params)
-    assert state.hash == hash_(rlp.encode(state))
+    assert state.root == hash_(rlp.encode(state))