PR Feedback

Author: hwwhww

eth/beacon/helpers.py

@@ -45,7 +45,7 @@ def _get_element_from_recent_list(
         target_slot: int,
         slot_relative_position: int) -> Any:
     """
-    Returns the element from ``target_list`` by the ``target_slot`` number,
+    Return the element from ``target_list`` by the ``target_slot`` number,
     where the the element should be at ``target_slot - slot_relative_position``th
     element of the given ``target_list``.
     """
@@ -75,7 +75,7 @@ def get_block_hash(
         slot: int,
         cycle_length: int) -> Hash32:
     """
-    Returns the blockhash from ``ActiveState.recent_block_hashes`` by
+    Return the blockhash from ``ActiveState.recent_block_hashes`` by
     ``current_block_slot_number``.
     """
     if len(recent_block_hashes) != cycle_length * 2:
@@ -192,7 +192,7 @@ def get_attestation_indices(crystallized_state: 'CrystallizedState',
                             attestation: 'AttestationRecord',
                             cycle_length: int) -> Iterable[int]:
     """
-    Returns committee of the given attestation.
+    Return committee of the given attestation.
     """
     shard_id = attestation.shard_id
 
@@ -231,7 +231,7 @@ def _get_shuffling_committee_slot_portions(
         min_committee_size: int,
         shard_count: int) -> Tuple[int, int]:
     """
-    Returns committees number per slot and slots number per committee.
+    Return committees number per slot and slots number per committee.
     """
     # If there are enough active validators to form committees for every slot
     if active_validators_size >= cycle_length * min_committee_size:
@@ -279,7 +279,7 @@ def get_new_shuffling(*,
                       min_committee_size: int,
                       shard_count: int) -> Iterable[Iterable[ShardAndCommittee]]:
     """
-    Returns shuffled ``shard_and_committee_for_slots`` (``[[ShardAndCommittee]]``) of
+    Return shuffled ``shard_and_committee_for_slots`` (``[[ShardAndCommittee]]``) of
     the given active ``validators``.
 
     Two-dimensional:
@@ -356,7 +356,7 @@ def get_block_committees_info(parent_block: 'BaseBeaconBlock',
         cycle_length,
     )
     """
-    Returns the proposer index in committee and the ``shard_id``.
+    Return the block committees and proposer info with BlockCommitteesInfo pack.
     """
     # `proposer_index_in_committee` th attester in `shard_and_committee`
     # is the proposer of the parent block.

eth/beacon/state_machines/base.py

@@ -260,6 +260,7 @@ def import_block(
             block,
             self.chaindb,
             self.config,
+            is_validating_signatures=True,
         )
 
         # Validate state roots
@@ -285,17 +286,20 @@ def process_block(
             active_state: ActiveState,
             block: BaseBeaconBlock,
             chaindb: BaseBeaconChainDB,
-            config: BeaconConfig) -> Tuple[BaseBeaconBlock, CrystallizedState, ActiveState]:
+            config: BeaconConfig,
+            is_validating_signatures: bool=True
+    ) -> Tuple[BaseBeaconBlock, CrystallizedState, ActiveState]:
         """
         Process ``block`` and return the new crystallized state and active state.
         """
         # Process per block state changes (ActiveState)
-        processing_active_state = cls.compute_per_block_transtion(
+        processing_active_state = cls.compute_per_block_transition(
             crystallized_state,
             active_state,
             block,
             chaindb,
             config.CYCLE_LENGTH,
+            is_validating_signatures=is_validating_signatures,
         )
 
         # Process per cycle state changes (CrystallizedState and ActiveState)
@@ -309,12 +313,13 @@ def process_block(
         return result_block, processed_crystallized_state, processed_active_state
 
     @classmethod
-    def compute_per_block_transtion(cls,
-                                    crystallized_state: CrystallizedState,
-                                    active_state: ActiveState,
-                                    block: BaseBeaconBlock,
-                                    chaindb: BaseBeaconChainDB,
-                                    cycle_length: int) -> ActiveState:
+    def compute_per_block_transition(cls,
+                                     crystallized_state: CrystallizedState,
+                                     active_state: ActiveState,
+                                     block: BaseBeaconBlock,
+                                     chaindb: BaseBeaconChainDB,
+                                     cycle_length: int,
+                                     is_validating_signatures: bool=True) -> ActiveState:
         """
         Process ``block`` and return the new ActiveState.
 
@@ -349,6 +354,7 @@ def compute_per_block_transtion(cls,
                 attestation,
                 chaindb,
                 cycle_length,
+                is_validating_signatures=is_validating_signatures,
             )
 
         return active_state.copy(
@@ -389,6 +395,7 @@ def propose_block(
             block_proposal.block,
             chaindb,
             config,
+            is_validating_signatures=False,
         )
 
         # Set state roots
@@ -405,7 +412,6 @@ def propose_block(
         proposer_attestation = self.attest_proposed_block(
             post_crystallized_state,
             post_active_state,
-            active_state,
             filled_block_proposal,
             chaindb,
             config.CYCLE_LENGTH,
@@ -422,7 +428,6 @@ def _update_the_states(self,
     def attest_proposed_block(self,
                               post_crystallized_state: CrystallizedState,
                               post_active_state: ActiveState,
-                              pre_active_state: ActiveState,
                               block_proposal: 'BlockProposal',
                               chaindb: BaseBeaconChainDB,
                               cycle_length: int,
@@ -461,13 +466,10 @@ def attest_proposed_block(self,
             block_proposal.shard_block_hash,
             justified_slot,
         )
-        sigs = [
-            bls.sign(
-                message,
-                private_key,
-            )
-        ]
-        aggregate_sig = bls.aggregate_sigs(sigs)
+        sig = bls.sign(
+            message,
+            private_key,
+        )
 
         return self.get_attestation_record_class()(
             slot=block_proposal.block.slot_number,
@@ -477,7 +479,7 @@ def attest_proposed_block(self,
             attester_bitfield=attester_bitfield,
             justified_slot=justified_slot,
             justified_block_hash=justified_block_hash,
-            aggregate_sig=aggregate_sig,
+            aggregate_sig=sig,
         )
 
     #

eth/beacon/state_machines/validation.py

@@ -95,7 +95,8 @@ def validate_attestation(
         recent_block_hashes: Iterable[Hash32],
         attestation: 'AttestationRecord',
         chaindb: BaseBeaconChainDB,
-        cycle_length: int) -> None:
+        cycle_length: int,
+        is_validating_signatures: bool=True) -> None:
     """
     Validate the given ``attestation``.
 
@@ -124,18 +125,19 @@ def validate_attestation(
     # TODO: implement versioning
     validate_version(crystallized_state, attestation)
 
-    parent_hashes = get_signed_parent_hashes(
-        recent_block_hashes,
-        block,
-        attestation,
-        cycle_length,
-    )
-    validate_aggregate_sig(
-        crystallized_state,
-        attestation,
-        attestation_indices,
-        parent_hashes,
-    )
+    if is_validating_signatures:
+        parent_hashes = get_signed_parent_hashes(
+            recent_block_hashes,
+            block,
+            attestation,
+            cycle_length,
+        )
+        validate_aggregate_sig(
+            crystallized_state,
+            attestation,
+            attestation_indices,
+            parent_hashes,
+        )
 
 
 def validate_slot(parent_block: 'BaseBeaconBlock',

tests/beacon/state_machines/test_state_machines.py

@@ -80,7 +80,7 @@ def test_import_block_one(fixture_sm_class,
         slot_number=genesis_block.slot_number + 1,
     )
     sm = fixture_sm_class(chaindb, block_1_shell)
-    active_state_1 = sm.compute_per_block_transtion(
+    active_state_1 = sm.compute_per_block_transition(
         sm.crystallized_state,
         sm.active_state,
         block_1_shell,

tests/beacon/test_aggregation.py

@@ -32,7 +32,7 @@ def test_aggregate_votes(votes_count, random, privkeys, pubkeys):
     pre_bitfield = get_empty_bitfield(bit_count)
     pre_sigs = ()
 
-    random_votes = random.sample([i for i in range(bit_count)], votes_count)
+    random_votes = random.sample(range(bit_count), votes_count)
     message = b'hello'
 
     # Get votes: (committee_index, sig, public_key)

tests/core/bitfield-utils/test_bitfields.py

@@ -140,7 +140,7 @@ def test_or_bitfields():
 @given(st.integers(1, 1000))
 def test_set_vote_and_has_vote(bit_count):
     bitfield = get_empty_bitfield(bit_count)
-    index = random.choice([i for i in range(bit_count)])
+    index = random.choice(range(bit_count))
     bitfield = set_voted(bitfield, index)
     assert has_voted(bitfield, index)
 
@@ -150,7 +150,7 @@ def test_set_vote_and_has_vote(bit_count):
 def test_has_voted_random(votes_count):
     bit_count = 1000
     bitfield = get_empty_bitfield(bit_count)
-    random_votes = random.sample([i for i in range(bit_count)], votes_count)
+    random_votes = random.sample(range(bit_count), votes_count)
 
     for index in random_votes:
         bitfield = set_voted(bitfield, index)