Merge pull request #1555 from hwwhww/data_rename

Rename data structures and constants

Author: hwwhww

eth/beacon/block_committees_info.py

@@ -5,7 +5,7 @@
 )
 
 if TYPE_CHECKING:
-    from eth.beacon.types.shard_and_committees import ShardAndCommittee  # noqa: F401
+    from eth.beacon.types.shard_committees import ShardCommittee  # noqa: F401
 
 
 BlockCommitteesInfo = NamedTuple(
@@ -15,6 +15,6 @@
         ('proposer_index_in_committee', int),
         ('proposer_shard_id', int),
         ('proposer_committee_size', int),
-        ('shards_and_committees', Tuple['ShardAndCommittee'])
+        ('shards_committees', Tuple['ShardCommittee'])
     )
 )

eth/beacon/enums/bls_domain.py renamed to eth/beacon/enums/signature_domain.py

@@ -2,7 +2,7 @@
 
 
 class SpecialRecordTypes(IntEnum):
-    LOGOUT = 0
+    VOLUNTARY_EXIT = 0
     CASPER_SLASHING = 1
     PROPOSER_SLASHING = 2
     DEPOSIT_PROOF = 3

eth/beacon/enums/special_record_types.py

@@ -0,0 +1,6 @@
+from enum import IntEnum
+
+
+class ValidatorRegistryDeltaFlag(IntEnum):
+    ACTIVATION = 0
+    EXIT = 1

eth/beacon/enums/validator_registry_delta_flags.py

@@ -26,8 +26,8 @@
 from eth.beacon.enums.validator_status_codes import (
     ValidatorStatusCode,
 )
-from eth.beacon.types.shard_and_committees import (
-    ShardAndCommittee,
+from eth.beacon.types.shard_committees import (
+    ShardCommittee,
 )
 from eth.beacon.utils.random import (
     shuffle,
@@ -77,20 +77,20 @@ def get_block_hash(
         recent_block_hashes: Sequence[Hash32],
         current_block_slot_number: int,
         slot: int,
-        cycle_length: int) -> Hash32:
+        epoch_length: int) -> Hash32:
     """
     Return the blockhash from ``ActiveState.recent_block_hashes`` by
     ``current_block_slot_number``.
     """
-    if len(recent_block_hashes) != cycle_length * 2:
+    if len(recent_block_hashes) != epoch_length * 2:
         raise ValueError(
-            "Length of recent_block_hashes != cycle_length * 2"
+            "Length of recent_block_hashes != epoch_length * 2"
             "\texpected: %s, found: %s" % (
-                cycle_length * 2, len(recent_block_hashes)
+                epoch_length * 2, len(recent_block_hashes)
             )
         )
 
-    slot_relative_position = current_block_slot_number - cycle_length * 2
+    slot_relative_position = current_block_slot_number - epoch_length * 2
     return _get_element_from_recent_list(
         recent_block_hashes,
         slot,
@@ -104,7 +104,7 @@ def get_hashes_from_recent_block_hashes(
         current_block_slot_number: int,
         from_slot: int,
         to_slot: int,
-        cycle_length: int) -> Iterable[Hash32]:
+        epoch_length: int) -> Iterable[Hash32]:
     """
     Returns the block hashes between ``from_slot`` and ``to_slot``.
     """
@@ -113,24 +113,24 @@ def get_hashes_from_recent_block_hashes(
             recent_block_hashes,
             current_block_slot_number,
             slot,
-            cycle_length,
+            epoch_length,
         )
 
 
 @to_tuple
 def get_hashes_to_sign(recent_block_hashes: Sequence[Hash32],
                        block: 'BaseBeaconBlock',
-                       cycle_length: int) -> Iterable[Hash32]:
+                       epoch_length: int) -> Iterable[Hash32]:
     """
     Given the head block to attest to, collect the list of hashes to be
     signed in the attestation.
     """
     yield from get_hashes_from_recent_block_hashes(
         recent_block_hashes,
         block.slot_number,
-        from_slot=block.slot_number - cycle_length + 1,
+        from_slot=block.slot_number - epoch_length + 1,
         to_slot=block.slot_number - 1,
-        cycle_length=cycle_length,
+        epoch_length=epoch_length,
     )
     yield block.hash
 
@@ -139,17 +139,17 @@ def get_hashes_to_sign(recent_block_hashes: Sequence[Hash32],
 def get_signed_parent_hashes(recent_block_hashes: Sequence[Hash32],
                              block: 'BaseBeaconBlock',
                              attestation: 'AttestationRecord',
-                             cycle_length: int) -> Iterable[Hash32]:
+                             epoch_length: int) -> Iterable[Hash32]:
     """
     Given an attestation and the block they were included in,
     the list of hashes that were included in the signature.
     """
     yield from get_hashes_from_recent_block_hashes(
         recent_block_hashes,
         block.slot_number,
-        from_slot=attestation.slot - cycle_length + 1,
+        from_slot=attestation.slot - epoch_length + 1,
         to_slot=attestation.slot - len(attestation.oblique_parent_hashes),
-        cycle_length=cycle_length,
+        epoch_length=epoch_length,
     )
     yield from attestation.oblique_parent_hashes
 
@@ -167,28 +167,28 @@ def get_new_recent_block_hashes(old_block_hashes: Sequence[Hash32],
 
 
 #
-# Get shards_and_committees or indices
+# Get shards_committees or indices
 #
 @to_tuple
-def get_shards_and_committees_for_slot(
+def get_shards_committees_for_slot(
         crystallized_state: 'CrystallizedState',
         slot: int,
-        cycle_length: int) -> Iterable[ShardAndCommittee]:
+        epoch_length: int) -> Iterable[ShardCommittee]:
     """
     FIXME
     """
-    if len(crystallized_state.shard_and_committee_for_slots) != cycle_length * 2:
+    if len(crystallized_state.shard_committee_for_slots) != epoch_length * 2:
         raise ValueError(
-            "Length of shard_and_committee_for_slots != cycle_length * 2"
+            "Length of shard_committee_for_slots != epoch_length * 2"
             "\texpected: %s, found: %s" % (
-                cycle_length * 2, len(crystallized_state.shard_and_committee_for_slots)
+                epoch_length * 2, len(crystallized_state.shard_committee_for_slots)
             )
         )
 
-    slot_relative_position = crystallized_state.last_state_recalc - cycle_length
+    slot_relative_position = crystallized_state.last_state_recalc - epoch_length
 
     yield from _get_element_from_recent_list(
-        crystallized_state.shard_and_committee_for_slots,
+        crystallized_state.shard_committee_for_slots,
         slot,
         slot_relative_position,
     )
@@ -197,22 +197,22 @@ def get_shards_and_committees_for_slot(
 @to_tuple
 def get_attestation_indices(crystallized_state: 'CrystallizedState',
                             attestation: 'AttestationRecord',
-                            cycle_length: int) -> Iterable[int]:
+                            epoch_length: int) -> Iterable[int]:
     """
     FIXME
     Return committee of the given attestation.
     """
     shard_id = attestation.shard_id
 
-    shards_and_committees_for_slot = get_shards_and_committees_for_slot(
+    shards_committees_for_slot = get_shards_committees_for_slot(
         crystallized_state,
         attestation.slot,
-        cycle_length,
+        epoch_length,
     )
 
-    for shard_and_committee in shards_and_committees_for_slot:
-        if shard_and_committee.shard_id == shard_id:
-            yield from shard_and_committee.committee
+    for shard_committee in shards_committees_for_slot:
+        if shard_committee.shard_id == shard_id:
+            yield from shard_committee.committee
 
 
 def get_active_validator_indices(validators: Sequence['ValidatorRecord']) -> Tuple[int, ...]:
@@ -229,17 +229,19 @@ def get_active_validator_indices(validators: Sequence['ValidatorRecord']) -> Tup
 # Shuffling
 #
 @to_tuple
-def _get_shards_and_committees_for_shard_indices(
+def _get_shards_committees_for_shard_indices(
         shard_indices: Sequence[Sequence[int]],
         start_shard: int,
-        shard_count: int) -> Iterable[ShardAndCommittee]:
+        total_validator_count: int,
+        shard_count: int) -> Iterable[ShardCommittee]:
     """
-    Returns filled [ShardAndCommittee] tuple.
+    Returns filled [ShardCommittee] tuple.
     """
     for index, indices in enumerate(shard_indices):
-        yield ShardAndCommittee(
+        yield ShardCommittee(
             shard=(start_shard + index) % shard_count,
-            committee=indices
+            committee=indices,
+            total_validator_count=total_validator_count,
         )
 
 
@@ -248,18 +250,18 @@ def get_new_shuffling(*,
                       seed: Hash32,
                       validators: Sequence['ValidatorRecord'],
                       crosslinking_start_shard: int,
-                      cycle_length: int,
+                      epoch_length: int,
                       target_committee_size: int,
-                      shard_count: int) -> Iterable[Iterable[ShardAndCommittee]]:
+                      shard_count: int) -> Iterable[Iterable[ShardCommittee]]:
     """
-    Return shuffled ``shard_and_committee_for_slots`` (``[[ShardAndCommittee]]``) of
+    Return shuffled ``shard_committee_for_slots`` (``[[ShardCommittee]]``) of
     the given active ``validators`` using ``seed`` as entropy.
 
     Two-dimensional:
     The first layer is ``slot`` number
-        ``shard_and_committee_for_slots[slot] -> [ShardAndCommittee]``
+        ``shard_committee_for_slots[slot] -> [ShardCommittee]``
     The second layer is ``shard_indices`` number
-        ``shard_and_committee_for_slots[slot][shard_indices] -> ShardAndCommittee``
+        ``shard_committee_for_slots[slot][shard_indices] -> ShardCommittee``
 
     Example:
         validators:
@@ -278,40 +280,41 @@ def get_new_shuffling(*,
             [
                 # slot 0
                 [
-                    ShardAndCommittee(shard_id=0, committee=[6, 0]),
-                    ShardAndCommittee(shard_id=1, committee=[2, 12, 14]),
+                    ShardCommittee(shard_id=0, committee=[6, 0]),
+                    ShardCommittee(shard_id=1, committee=[2, 12, 14]),
                 ],
                 # slot 1
                 [
-                    ShardAndCommittee(shard_id=2, committee=[8, 10]),
-                    ShardAndCommittee(shard_id=3, committee=[4, 9, 1]),
+                    ShardCommittee(shard_id=2, committee=[8, 10]),
+                    ShardCommittee(shard_id=3, committee=[4, 9, 1]),
                 ],
                 # slot 2
                 [
-                    ShardAndCommittee(shard_id=4, committee=[5, 13, 15]),
-                    ShardAndCommittee(shard_id=5, committee=[7, 3, 11]),
+                    ShardCommittee(shard_id=4, committee=[5, 13, 15]),
+                    ShardCommittee(shard_id=5, committee=[7, 3, 11]),
                 ],
             ]
     """
     active_validators = get_active_validator_indices(validators)
     active_validators_size = len(active_validators)
     committees_per_slot = clamp(
         1,
-        shard_count // cycle_length,
-        active_validators_size // cycle_length // target_committee_size,
+        shard_count // epoch_length,
+        active_validators_size // epoch_length // target_committee_size,
     )
     # Shuffle with seed
     shuffled_active_validator_indices = shuffle(active_validators, seed)
 
     # Split the shuffled list into epoch_length pieces
-    validators_per_slot = split(shuffled_active_validator_indices, cycle_length)
+    validators_per_slot = split(shuffled_active_validator_indices, epoch_length)
     for index, slot_indices in enumerate(validators_per_slot):
         # Split the shuffled list into committees_per_slot pieces
         shard_indices = split(slot_indices, committees_per_slot)
         start_shard = crosslinking_start_shard + index * committees_per_slot
-        yield _get_shards_and_committees_for_shard_indices(
+        yield _get_shards_committees_for_shard_indices(
             shard_indices,
             start_shard,
+            active_validators_size,
             shard_count,
         )
 
@@ -321,24 +324,24 @@ def get_new_shuffling(*,
 #
 def get_block_committees_info(parent_block: 'BaseBeaconBlock',
                               crystallized_state: 'CrystallizedState',
-                              cycle_length: int) -> BlockCommitteesInfo:
-    shards_and_committees = get_shards_and_committees_for_slot(
+                              epoch_length: int) -> BlockCommitteesInfo:
+    shards_committees = get_shards_committees_for_slot(
         crystallized_state,
         parent_block.slot_number,
-        cycle_length,
+        epoch_length,
     )
     """
     FIXME
     Return the block committees and proposer info with BlockCommitteesInfo pack.
     """
-    # `proposer_index_in_committee` th attester in `shard_and_committee`
+    # `proposer_index_in_committee` th attester in `shard_committee`
     # is the proposer of the parent block.
     try:
-        shard_and_committee = shards_and_committees[0]
+        shard_committee = shards_committees[0]
     except IndexError:
-        raise ValueError("shards_and_committees should not be empty.")
+        raise ValueError("shards_committees should not be empty.")
 
-    proposer_committee_size = len(shard_and_committee.committee)
+    proposer_committee_size = len(shard_committee.committee)
     if proposer_committee_size <= 0:
         raise ValueError(
             "The first committee should not be empty"
@@ -350,12 +353,12 @@ def get_block_committees_info(parent_block: 'BaseBeaconBlock',
     )
 
     # The index in CrystallizedState.validators
-    proposer_index = shard_and_committee.committee[proposer_index_in_committee]
+    proposer_index = shard_committee.committee[proposer_index_in_committee]
 
     return BlockCommitteesInfo(
         proposer_index=proposer_index,
         proposer_index_in_committee=proposer_index_in_committee,
-        proposer_shard_id=shard_and_committee.shard_id,
+        proposer_shard_id=shard_committee.shard_id,
         proposer_committee_size=proposer_committee_size,
-        shards_and_committees=shards_and_committees,
+        shards_committees=shards_committees,
     )